Czy istnieje sposób wykonywania tego rodzaju rzutowania w predykacie C#

Question

Próbuję utworzyć ogólną metodę, która zwróci predykat w celu znalezienia elementów w dokumencie XML.

Zasadniczo coś takiego:

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."); 
    } 
} 

Jedyną rzeczą jest to, że nie kompiluje. Problem polega na (T)x.Attribute(criterion.PropertyName) części, gdzie kompilator wskazuje:

Nie można rzucać wyrażenia typu „System.Xml.Linq.XAttribute” do rodzaju

Obecnie mam dwie metody „T”, które są identyczne, z wyjątkiem tego, że jeden rzutuje na podwójny, a drugi na dziesiętny. Naprawdę chciałbym nie mieć tego rodzaju duplikacji.

Answer 1

XAttribute Class definiuje kilka conversion operators. Jednak podczas rzutowania na ogólny typ parametru T operatory te nie są brane pod uwagę.

Co można zrobić, to zbudować wyrażenia lambda w czasie wykonywania w sposób następujący:

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(); 
} 

Zastosowanie:

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

Nie ma żadnego implicit or explicit conversions dla dowolnego typu T. Jedynymi konwersje dozwolony od XAttribute do innego typu są jawne i do tych typów:

• 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>

Będziesz musiał utworzyć przeciążenia, które przyjmą jeden z powyższych typów i ograniczyć połączenia do jednego z nich.

Answer 3

Co to jest T? An XAttribute nie można przekonwertować na niego, chyba że jest jakiś rodzaj ograniczenia na generic. W każdym razie prawdopodobnie chcesz uzyskać Attribute().Value, który jest ciągiem znaków. Następnie możesz zrobić porównanie. Jaki jest typ criterion.PropertyValue?

Jeśli twój XML zawiera prymitywy takie jak liczby, nie możesz po prostu rzucić łańcucha prosto na liczbę. Musisz użyć metod takich jak double.TryParse(). Niestety, nie ma możliwości, bym ograniczył rodzajowy do metody TryParse. Gdyby tak było, byłbyś w stanie powiedzieć T.TryParse. Ale nie ma sposobu, więc nie możesz. Generics prawdopodobnie ci w tym nie pomoże.

Answer 4

Dodaj XAttribute constrait na metody rodzajowe:

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

Answer 5

Jeśli po prostu zastąpić odlewane do T z odlewów do dynamic, to wtedy by działało. Nie czułbym się źle z powodu wyrzucenia bezpieczeństwa typu tutaj, ponieważ prawdopodobnie nie możesz zagwarantować, że rzeczy w atrybutach XML są w każdym razie właściwym typem - więc bezpieczeństwo typu było iluzją przez cały czas.

Answer 6

Nie można porównać dwóch T s przy użyciu ==, ale powinno działać object.Equals().

Aby wykonać konwersję, można użyć Convert.ChangeType():

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

Problem polega na tym, że XML wykorzystuje różne zasady konwersji w niektórych przypadkach (np Double.PositiveInfinity jest reprezentowany jako INF).

Aby rozwiązać ten problem, można użyć the XmlConvert class, który jest używany wewnętrznie przez operatorów konwersji. Oprócz tego, że nie ma „rodzajowe” metody jak Convert.ChangeType(), więc trzeba by tworzyć własne:

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);