DEV Community: Juan Fernando Alzate

Nomus: Normalización de strings en .NET

Juan Fernando Alzate — Fri, 23 Oct 2026 15:55:32 +0000

Cuando trabajas simultáneamente con APIs, bases de datos y aplicaciones frontend, es casi inevitable encontrarte con inconsistencias en las convenciones de nomenclatura. En el ecosistema moderno de desarrollo con .NET, donde conviven múltiples capas y sistemas con reglas distintas, lo que al equipo parece un detalle menor termina convirtiéndose en una fuente constante de fricción dentro del código.

Es ahí cuando paquetes como Nomus entran a intervenir.

En este artículo te enseñaré a instalar el paquete Nomus en .Net y a implementarlo con un ejemplo práctico, pero antes de empezar definamos:

¿Qué es Nomus?

Es un paquete NuGet diseñado para aplicaciones en .NET 8.0 y superiores, cuyo objetivo es simplificar la normalización y conversión de strings entre distintos estilos de casing.

¿Qué problema resuelve?

Cuando trabajas con múltiples sistemas, es común encontrarte con distintos formatos de nombres:

APIs que usan camelCase
Bases de datos con snake_case
Clases en PascalCase
URLs en kebab-case

Sin una herramienta adecuada, terminas escribiendo lógica manual para cada caso —lo que no solo consume tiempo, sino que introduce inconsistencias.

Nomus elimina ese problema con una API simple y directa.

Funcionalidades principales

Detecta: Detecta automáticamente el formato original del texto (UpperCase, PascalCase, TrainCase, etc).

Convierte: Convierte texto fácilmente entre múltiples formatos de manera intuitiva:

PascalCase → HolaMundo
camelCase → holaMundo
kebab-case → hola-mundo
snake_case → hola_mundo
Title Case → Hola Mundo

Todo esto en una sola línea de código, sin necesidad de expresiones regulares complejas ni lógica personalizada.

Empecemos

Instalación:

Opción 1: Desde Visual Studio, damos clic derecho en el nombre del proyecto, seleccionamos Manage NuGet Packages → Browse → Nomus

Opción 2: Desde la consola:

dotnet add package Devjavu.Nomus

Implementación:

Uso rápido

using Nomus;

// Detect naming style
var detected = Naming.DetectNamingStyle("votesUsers");
// "camelCase"

// PascalCase
var p = Naming.ToPascalCase("user_votes_details");
// UserVotesDetails

// camelCase
var c = Naming.ToCamelCase("UserVotesDetails");
// userVotesDetails

// snake_case
var s = Naming.ToSnakeCase("userVotesDetails");
// user_votes_details

// kebab-case
var k = Naming.ToKebabCase("userVotesDetails");
// user-votes-details

Ejemplo práctico

Supongamos que tenemos este modelo:

public class UsuarioDto
{
    public string NombreCompleto { get; set; }
    public string FechaRegistro { get; set; }
}

Por defecto, ASP.NET Core ya convierte a camelCase, pero si necesitas control total o formatos personalizados, puedes usar Nomus.

Transformamos el modelo con Nomus:

using Devjavu.Nomus;

var data = new Dictionary<string, object>()
{
    { "NombreCompleto", "Juan Alzate" },
    { "FechaRegistro", "2026-01-01" }
};

var transformed = data.ToDictionary(
    key => Nomus.ToCamelCase(key.Key),
    value => value.Value
);

Resultado:

{
  "nombreCompleto": "Juan Alzate",
  "fechaRegistro": "2026-01-01"
}

Podemos ir mas allá y crear un helper reutilizable:

public static class NomusExtensions
{
    public static Dictionary<string, object> ToCamelCaseKeys(this object obj)
    {
        var dict = obj.GetType()
            .GetProperties()
            .ToDictionary(
                prop => Nomus.ToCamelCase(prop.Name),
                prop => prop.GetValue(obj)
            );

        return dict;
    }
}

Lo usamos:

var usuario = new UsuarioDto
{
    NombreCompleto = "Juan Alzate",
    FechaRegistro = "2026-01-01"
};

var response = usuario.ToCamelCaseKeys();

Bonus: generar slugs para URLs

Podemos utilizar Nomus para SEO o rutas limpias:

string titulo = "Curso de .NET para Principiantes";
string slug = Nomus.ToKebabCase(titulo);

// resultado: "curso-de-net-para-principiantes"

¿Por qué usar Nomus?

Porque te permite:

Reducir código repetitivo.
Evitar errores en conversiones manuales.
Mantener consistencia en tu proyecto.
Mejorar la legibilidad del código.

Y lo más importante: enfocarte en lógica de negocio, no en manipulación de strings.

Conclusión

Nomus es una herramienta ligera pero poderosa que resuelve un problema cotidiano en el desarrollo de software. Si trabajas con múltiples formatos de nomenclatura en .NET, este paquete puede ahorrarte tiempo y dolores de cabeza.

Nomus: String Normalization in .NET

Juan Fernando Alzate — Thu, 22 Oct 2026 21:50:44 +0000

When you work simultaneously with APIs, databases, and frontend applications, it’s almost inevitable to run into inconsistencies in naming conventions. In the modern .NET development ecosystem, where multiple layers and systems with different rules coexist, what may seem like a minor detail to the team often becomes a constant source of friction within the code.

That’s where packages like Nomus come into play.

In this article, I’ll show you how to install the Nomus package in .NET and how to implement it with a practical example — but before we begin, let’s define:

What is Nomus?

It’s a NuGet package designed for applications in .NET 8.0 and above, aimed at simplifying string normalization and conversion between different casing styles.

What problem does it solve?

When working with multiple systems, it’s common to encounter different naming formats:

APIs that use camelCase
Databases with snake_case
Classes in PascalCase
URLs in kebab-case

Without the right tool, you end up writing manual logic for each case — which not only takes time but also introduces inconsistencies.

Nomus eliminates this problem with a simple and straightforward API.

Key Features

Detect: Automatically detects the original text format (UpperCase, PascalCase, TrainCase, etc).

Convert: Easily converts text between multiple formats in an intuitive way:

PascalCase → HolaMundo
camelCase → holaMundo
kebab-case → hola-mundo
snake_case → hola_mundo
Title Case → Hola Mundo

All of this in a single line of code, without the need for complex regular expressions or custom logic.

Let’s Get Started

Installation:
Option 1: From Visual Studio, right-click on the project name, select Manage NuGet Packages → Browse → Nomus

Option 2: From the console:

dotnet add package Devjavu.Nomus

Implementation

Quick usage:

using Nomus;

// Detect naming style
var detected = Naming.DetectNamingStyle("votesUsers");
// "camelCase"

// PascalCase
var p = Naming.ToPascalCase("user_votes_details");
// UserVotesDetails

// camelCase
var c = Naming.ToCamelCase("UserVotesDetails");
// userVotesDetails

// snake_case
var s = Naming.ToSnakeCase("userVotesDetails");
// user_votes_details

// kebab-case
var k = Naming.ToKebabCase("userVotesDetails");
// user-votes-details

Practical Example

Suppose we have this model:

public class UserDto
{
    public string FullName { get; set; }
    public string RegistrationDate { get; set; }
}

By default, ASP.NET Core already converts to camelCase, but if you need full control or custom formats, you can use Nomus.

Let's transform the model with Nomus:

using Devjavu.Nomus;

var data = new Dictionary<string, object>()
{
    { "FullName", "Jhon Alzate" },
    { "RegistrationDate", "2026-01-01" }
};

var transformed = data.ToDictionary(
    key => Nomus.ToCamelCase(key.Key),
    value => value.Value
);

Result:

{
  "fullName": "Jhon Alzate",
  "registrationDate": "2026-01-01"
}

We can go further and create a reusable helper:

public static class NomusExtensions
{
    public static Dictionary<string, object> ToCamelCaseKeys(this object obj)
    {
        var dict = obj.GetType()
            .GetProperties()
            .ToDictionary(
                prop => Nomus.ToCamelCase(prop.Name),
                prop => prop.GetValue(obj)
            );

        return dict;
    }
}

Usage:

var usuario = new UsuarioDto
{
    FullName = "Jhon Alzate",
    RegistrationDate = "2026-01-01"
};

var response = usuario.ToCamelCaseKeys();

Bonus: generate URL Slugs

You can use Nomus for SEO or clean routes:

string title = ".NET Course for Beginners";
string slug = Nomus.ToKebabCase(titulo);

// result: "net-course-for-beginners"

Why use Nomus?

Because it allows you to:

Reduce repetitive code
Avoid errors in manual conversions
Maintain consistency in your project
Improve code readability

And most importantly: focus on business logic, not string manipulation.

Conclusion

Nomus is a lightweight yet powerful tool that solves a common problem in software development. If you work with multiple naming formats in .NET, this package can save you time and headaches.