Type Map Pattern (Patrón de Mapa de Tipos)

1. Definición

El Type Map Pattern es un patrón de diseño que consiste en asociar un tipo con un comportamiento o función específica mediante una estructura de datos, normalmente un Dictionary<Type, ...>.

Permite reemplazar estructuras condicionales complejas como:

• if
• switch
• validaciones por tipo

por un lookup dinámico basado en el tipo.

La idea principal es convertir la lógica en datos configurables.

2. Problema que resuelve

En muchos sistemas existen comportamientos diferentes dependiendo del tipo de objeto.

Implementación tradicional:

if(typeof(T) == typeof(Activity))
    return GetActivity(id);

if(typeof(T) == typeof(Meal))
    return GetMeal(id);

if(typeof(T) == typeof(Transport))
    return GetTransport(id);

Problemas:

• Código repetitivo
• Difícil de extender
• Viola el Open/Closed Principle
• Aumenta la complejidad conforme se agregan tipos

3. Solución con Type Map

El patrón propone usar una estructura de registro:

Dictionary<Type, Func<string, object?>> _map;

Donde:

Key Value

Tipo Función o comportamiento asociado

Ejemplo:

_map = new()
{
    { typeof(Activity), id => Activities.FirstOrDefault(x => x.Id == id) },
    { typeof(Meal), id => Meals.FirstOrDefault(x => x.Id == id) },
    { typeof(Transport), id => Transports.FirstOrDefault(x => x.Id == id) }
};

4. Uso

Luego el código se simplifica:

public T? GetItemById<T>(string id) where T : class
{
    if(!_map.TryGetValue(typeof(T), out var finder))
        throw new NotSupportedException();

    return finder(id) as T;
}

El tipo determina automáticamente la estrategia a utilizar.

5. Flujo de ejecución

Solicitud de tipo
        │
        ▼
 typeof(T)
        │
        ▼
Dictionary lookup
        │
        ▼
Func asociada
        │
        ▼
Resultado

6. Ventajas

• Reduce código condicional
• Mejora la extensibilidad
• Facilita el mantenimiento
• Implementación simple
• Cumple Open/Closed Principle

Agregar un nuevo tipo solo requiere registrar una nueva entrada en el mapa.

7. Desventajas

• Puede ser menos explícito para desarrolladores nuevos
• Si el mapa crece demasiado puede requerir organización adicional
• Requiere control de tipos no registrados

8. Casos de uso comunes

El Type Map se utiliza frecuentemente en:

• Serializadores
• ORMs
• Dependency Injection Containers
• Caches internas
• Factories dinámicas
• Sistemas de conversión de tipos

9. Ejemplos reales en .NET

El patrón aparece internamente en:

• System.Text.Json (Type → JsonConverter)
• AutoMapper (TypePair → MappingFunction)
• ASP.NET Core DI (Type → ServiceFactory)
• Entity Framework Core (Type → ValueConverter)

10. Relación con otros patrones

El Type Map suele combinarse con:

Patrón Relación

Strategy El mapa selecciona la estrategia Factory El mapa decide qué instancia crear Registry El mapa actúa como registro de comportamientos Table Driven Design La lógica se convierte en datos

11. Cuándo usarlo

Usa Type Map cuando:

• necesitas ejecutar lógica distinta dependiendo del tipo
• quieres evitar múltiples if o switch
• el sistema debe ser extensible
• necesitas registrar comportamientos dinámicamente