Un poco de programa educativo

Realmente me gusta Automapper, especialmente sus QueryableExtensions y el método ProjectTo <> . En resumen, este método permite la proyección de tipos directamente en la consulta SQL. Permitió recibir dto realmente de una base de datos. Es decir no es necesario obtener todas las entidades de la base de datos, cargarlas en la memoria, usar Automapper.Map<> , lo que condujo a un gran consumo y tráfico de memoria.

Tipo de proyección

Para obtener una proyección en linq, necesitabas escribir algo como esto:

  from user in dbContext.Users where user.IsActive select new { Name = user.Name, Status = user.IsConnected ? "Connected" : "Disconnected" } 

Usando QueryableExtensions, este código se puede reemplazar con lo siguiente (por supuesto, siempre que las reglas de conversión Usuario -> Información de usuario ya estén descritas)

 dbContext.Users.Where(x => x.IsActive).ProjectTo<UserInfo>(); 

Enum y problemas con ella

La proyección tiene un inconveniente que debe considerarse. Esta es una restricción en las operaciones realizadas. No todo se puede traducir en una consulta SQL . En particular, no es posible obtener información por tipo de enumeración. Por ejemplo, existe la siguiente enumeración

  public enum FooEnum { [Display(Name = "")] Any, [Display(Name = "")] Open, [Display(Name = "")] Closed } 

Hay una entidad en la que se declara una propiedad de tipo FooEnum. En dto, no necesita obtener Enum, sino el valor de la propiedad Name del atributo DisplayAttribute. Darse cuenta de esto a través de la proyección no funciona, porque obtener el valor del atributo requiere Reflection, del cual SQL simplemente "no sabe nada".

Como resultado, debe usar el Map<> habitual Map<> , cargar todas las entidades en la memoria o iniciar una tabla adicional con valores Enum y claves foráneas.

Hay una solución: expresiones

Pero "habrá un golpe en la anciana". Después de todo, todos los valores de Enum se conocen de antemano. SQL tiene una implementación de switch que puede insertar al formar una proyección. Queda por entender cómo hacer esto. HashTag: "Expression Trees-Our-All".

Automapper, al proyectar tipos, puede convertir una expresión en una expresión que, después de Entity Framework, se convierte en la consulta SQL correspondiente.

A primera vista, la sintaxis para crear árboles de expresión en tiempo de ejecución es extremadamente inconveniente. Pero después de algunos pequeños problemas resueltos, todo se vuelve obvio. Para resolver el problema con Enum, debe crear un árbol anidado de expresiones condicionales que devuelvan valores, según los datos de origen. Algo como esto

 IF enum=Any THEN RETURN "" ELSE IF enum=Open THEN RETURN "" ELSE enum=Closed THEN RETURN "" ELSE RETURN "" 

Decidir sobre la firma del método.

  public class FooEntity { public int Id { get; set; } public FooEnum Enum { get; set; } } public class FooDto { public int Id { get; set; } public string Name { get; set; } } //  Automapper CreateMap<FooEntity, FooDto>() .ForMember(x => x.Enum, options => options.MapFrom(GetExpression())); private Expression<Func<FooEntity, string>> GetExpression() { } 

El método GetExpression() debe generar una expresión que recibe una instancia de FooEntity y devuelve una representación de cadena para la propiedad Enum .
Primero, defina el parámetro de entrada y obtenga el valor de la propiedad

 ParameterExpression value = Expression.Parameter(typeof(FooEntity), "x"); var propertyExpression = Expression.Property(value, "Enum"); 

En lugar de la cadena de nombre de propiedad, puede usar el nameof(FooEntity.Enum) compilador nameof(FooEntity.Enum) o incluso obtener datos sobre la propiedad System.Reflection.PropertyInfo o el captador System.Reflection.MethodInfo . Pero por el bien de los ejemplos, es suficiente para nosotros establecer explícitamente el nombre de la propiedad.

Para devolver un valor específico, utilizamos el método Expression.Constant . Formamos el valor por defecto

  Expression resultExpression = Expression.Constant(string.Empty); 

Después de eso, sucesivamente "envolvemos" el resultado en una condición.

  resultExpression = Expression.Condition( Expression.Equal(propertyExpression, Expression.Constant(FooEnum.Any)), Expression.Constant(EnumHelper.GetShortName(FooEnum.Any)), resultExpression); resultExpression = Expression.Condition( Expression.Equal(propertyExpression, Expression.Constant(FooEnum.Open)), Expression.Constant(EnumHelper.GetShortName(FooEnum.Open)), resultExpression); resultExpression = Expression.Condition( Expression.Equal(propertyExpression, Expression.Constant(FooEnum.Closed)), Expression.Constant(EnumHelper.GetShortName(FooEnum.Closed)), resultExpression); 

  public static class EnumHelper { public static string GetShortName(this Enum enumeration) { return (enumeration .GetType() .GetMember(enumeration.ToString())? .FirstOrDefault()? .GetCustomAttributes(typeof(DisplayAttribute), false)? .FirstOrDefault() as DisplayAttribute)? .ShortName ?? enumeration.ToString(); } } 

Todo lo que queda es elaborar el resultado.

  return Expression.Lambda<Func<TEntity, string>>(resultExpression, value); 

Un poco mas de reflexion

Copiar todos los valores de Enum es extremadamente inconveniente. Vamos a arreglarlo

  var enumValues = Enum.GetValues(typeof(FooEnum)).Cast<Enum>(); Expression resultExpression = Expression.Constant(string.Empty); foreach (var enumValue in enumValues) { resultExpression = Expression.Condition( Expression.Equal(propertyExpression, Expression.Constant(enumValue)), Expression.Constant(EnumHelper.GetShortName(enumValue)), resultExpression); } 

Mejoremos obteniendo el valor de la propiedad

La desventaja del código anterior es la estrecha vinculación del tipo de entidad utilizada. Si se necesita resolver un problema similar en relación con otra clase, debe encontrar una forma de obtener el valor de una propiedad de enumeración de tipos. Así que deja que la expresión lo haga por nosotros. Como parámetro del método, pasaremos una expresión que recibe el valor de la propiedad y el código en sí mismo; simplemente formamos un conjunto de resultados para esta propiedad posible. Plantillas para ayudarnos

  public static Expression<Func<TEntity, string>> CreateEnumShortNameExpression<TEntity, TEnum>(Expression<Func<TEntity, TEnum>> propertyExpression) where TEntity : class where TEnum : struct { var enumValues = Enum.GetValues(typeof(TEnum)).Cast<Enum>(); Expression resultExpression = Expression.Constant(string.Empty); foreach (var enumValue in enumValues) { resultExpression = Expression.Condition( Expression.Equal(propertyExpression.Body, Expression.Constant(enumValue)), Expression.Constant(EnumHelper.GetShortName(enumValue)), resultExpression); } return Expression.Lambda<Func<TEntity, string>>(resultExpression, propertyExpression.Parameters); } 

Algunas aclaraciones Porque obtenemos el valor de entrada a través de otra expresión, luego no necesitamos declarar el parámetro a través de Expression.Parameter . Tomamos este parámetro de la propiedad de la expresión de entrada y usamos el cuerpo de la expresión para obtener el valor de la propiedad.
Entonces puedes usar el nuevo método como este:

  CreateMap<FooEntity, FooDto>() .ForMember(x => x.Enum, options => options.MapFrom(GetExpression<FooEntity, FooEnum>(x => x.Enum))); 

Todo el desarrollo exitoso de árboles de expresión.

Recomiendo leer los artículos de Maxim Arshinov . Especialmente sobre Expression Trees en el desarrollo empresarial .