¿Hay alguna manera de hacer este tipo de conversión en un predicado C#

Question

? Estoy intentando crear un método genérico que devuelva un predicado para encontrar elementos en un documento XML.

Básicamente algo como esto:

private static Func<XElement, bool> GetPredicate<T>(Criterion criterion) 
{ 
    switch (criterion.CriteriaOperator) 
    { 
     case CriteriaOperator.Equal: 
      return x => (T)x.Attribute(criterion.PropertyName) == 
       (T)(criterion.PropertyValue); 
     case CriteriaOperator.GreaterThan: 
      return x => (T)x.Attribute(criterion.PropertyName) > 
       (T)(criterion.PropertyValue); 
     case CriteriaOperator.GreaterThanOrEqual: 
      return x => (T)x.Attribute(criterion.PropertyName) >= 
       (T)(criterion.PropertyValue); 
     case CriteriaOperator.LessThan: 
      return x => (T)x.Attribute(criterion.PropertyName) < 
       (T)(criterion.PropertyValue); 
     case CriteriaOperator.LessThanOrEqual: 
      return x => (T)x.Attribute(criterion.PropertyName) <= 
       (T)(criterion.PropertyValue); 
     case CriteriaOperator.NotEqual: 
      return x => (T)x.Attribute(criterion.PropertyName) != 
       (T)(criterion.PropertyValue); 
     default: 
      throw new ArgumentException("Criteria Operator not supported."); 
    } 
} 

Lo único es que esto no se compila. El problema está en la parte (T)x.Attribute(criterion.PropertyName) donde el compilador indica:

no puede lanzar expresión de tipo 'System.Xml.Linq.XAttribute' para escribir

Actualmente tengo dos métodos 'T' que son idénticos, excepto que uno arroja al doble y el otro a decimal. Realmente me gustaría no tener ese tipo de duplicación.

Answer 1

El XAttribute Class define varias conversion operators. Sin embargo, al convertir a un parámetro de tipo genérico T, estos operadores no se tienen en cuenta.

Lo que puede hacer es construir la expresión lambda en tiempo de ejecución de la siguiente manera:

private static Func<XElement, bool> GetPredicate<T>(Criterion criterion) 
{ 
    var arg = Expression.Parameter(typeof(XElement), "arg"); 
    var name = Expression.Constant((XName)criterion.PropertyName); 
    var attr = Expression.Call(arg, "Attribute", null, name); 
    var left = Expression.Convert(attr, typeof(T)); 
    var right = Expression.Constant(criterion.PropertyValue, typeof(T)); 

    Expression body; 

    switch (criterion.CriteriaOperator) 
    { 
    case CriteriaOperator.Equal: 
     body = Expression.Equal(left, right); 
     break; 
    case CriteriaOperator.GreaterThan: 
     body = Expression.GreaterThan(left, right); 
     break; 
    default: 
     throw new ArgumentException("Criteria Operator not supported."); 
    } 

    return Expression.Lambda<Func<XElement, bool>>(body, arg).Compile(); 
} 

Uso:

var f = GetPredicate<int>(new Criterion("documentversion", CO.GreaterThan, 8)); 
var g = GetPredicate<string>(new Criterion("documentid", CO.Equal, "DOC-5X")); 
var h = GetPredicate<double>(new Criterion("documentprice", CO.Equal, 85.99d)); 

Answer 2

No hay implicit or explicit conversions en un tipo arbitrario T. Las únicas conversiones permitidas de XAttribute a otro tipo son explícitas y para estos tipos:

• Boolean
• Nullable<Boolean>
• DateTime
• Nullable<DateTime>
• DateTimeOffset
• Nullable<DateTimeOffset>
• Decimal
• Nullable<Decimal>
• Double
• Nullable<Double>
• Guid
• Nullable<Guid>
• Int32
• Nullable<Int32>
• Int64
• Nullable<Int64>
• Single
• Nullable<Single>
• String
• TimeSpan
• Nullable<TimeSpan>
• UInt32
• Nullable<UInt32>
• UInt64
• Nullable<UInt64>

Deberá crear sobrecargas que tengan uno de los tipos anteriores y limitar las llamadas a una de ellas.

Answer 3

¿Qué se supone que es T? No se puede convertir un XAttribute a menos que haya algún tipo de restricción en el genérico. En cualquier caso, es probable que desee obtener Attribute().Value, que es una cadena. Entonces puedes hacer una comparación. ¿Cuál es el tipo de criterion.PropertyValue?

Si su XML contiene primitivas como números, no puede simplemente lanzar una cadena directamente a un número. Debe usar métodos como double.TryParse(). Lamentablemente, no hay manera de que sepa restringir un genérico para tener un método TryParse. Si hubiera, podría decir T.TryParse. Pero no hay forma, entonces no puedes. Los genéricos probablemente no te ayudarán con esto.

Answer 4

Añadir XAttribute constrait el método genérico:

GetPredicate<T>(Criterion criterion) where T : XAttribute 

Answer 5

Si acaba de cambiar sus moldes a T con los moldes a dynamic, se funcionaría entonces. No me sentiría mal por tirar la seguridad del tipo aquí, ya que probablemente no puedas asegurarte de que las cosas en los atributos XML sean del tipo correcto de todos modos, así que la seguridad del tipo fue una ilusión todo el tiempo.

Answer 6

No puede comparar dos T s usando ==, pero object.Equals() debería funcionar.

para hacer la conversión, usted podría utilizar Convert.ChangeType():

case CriteriaOperator.Equal: 
    return x => object.Equals(
     Convert.ChangeType(x.Attribute(criterion.PropertyName).Value, typeof(T)), 
     criterion.PropertyValue); 

El problema con esto es que XML utiliza diferentes reglas para las conversiones en algunos casos (por ejemplo Double.PositiveInfinity se representa como INF).

Para resolver esto, puede usar the XmlConvert class, que los operadores de conversión utilizan internamente. Excepto que no tienen un método “genérico” como Convert.ChangeType(), por lo que tendría que crear su propia:

private static object Convert(string value, Type targetType) 
{ 
    if (targetType == typeof(double)) 
     return XmlConvert.ToDouble(value); 

    … 

    throw new ArgumentException(); 
} 

… 

case CriteriaOperator.Equal: 
    return x => object.Equals(
     Convert(x.Attribute(criterion.PropertyName).Value, typeof(T)), 
     criterion.PropertyValue);