Nomus: Normalización de strings en .NET

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.

Este desalineamiento obliga a los desarrolladores a escribir lógica repetitiva para transformar strings entre distintos formatos. Aunque al inicio parece trivial, con el tiempo introduce problemas como:

• Código duplicado
• Inconsistencias en los datos
• Mayor probabilidad de errores
• Dificultad para mantener y escalar el proyecto

Además, cuando trabajas en equipos o integras múltiples servicios, mantener una convención uniforme se vuelve aún más complejo.

Es ahí cuando paquetes como Nomus entran a intervenir. 

🧠 Resumen rápido

Nomus es un paquete NuGet para .NET que permite:

• Detectar automáticamente el formato de un string
• Convertir entre camelCase, PascalCase, snake_case y kebab-case
• Simplificar la manipulación de texto sin lógica manual

Es ideal para desarrolladores que trabajan con APIs, bases de datos o múltiples convenciones de nomenclatura.

En este artículo te enseñaré a implementar el paquete Nomus en .Net, 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 más 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"

🔗 Casos de uso reales

Nomus es especialmente útil en:

• Desarrollo de APIs REST
• Transformación de datos entre backend y frontend
• Migración de sistemas con diferentes convenciones
• Generación de URLs amigables para SEO

¿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.

❓ Preguntas frecuentes

¿Nomus funciona con versiones anteriores a .NET 8?

Está diseñado para .NET 8 en adelante, por lo que puede no ser compatible con versiones anteriores.

¿Se puede usar en APIs?

Sí, es ideal para transformar datos entre diferentes capas.

¿Es mejor que usar expresiones regulares?

Sí, porque simplifica el código y reduce errores.

📈 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.