C# 将某些泛型类型的类属性强制转换为泛型类型以执行方法

首先，我想为这个混乱的标题道歉。我不太清楚如何用语言来表达，所以我将描述一下情况

我正在为我们的产品编写一个比较引擎，它能够比较不同的产品，例如：

public abstract class ComparableProduct
{
    public ComparableProperty<decimal> Weight { get; set; }
    public ComparableProperty<decimal> Width { get; set; }
    public ComparableProperty<decimal> Height { get; set; }
    public ComparableProperty<decimal> Depth { get; set; }
    public bool IsBetterThan(ComparableProduct target){}
}

public abstract class ComparableProperty<T> where T : IComparable<T>
{
    T Value { get; set; }
    public ComparisonType ComparisonType { get; set; }
    public bool IsBetterThan(T target)
    {
        if(ComparisonType == ComparisonType.GreaterThan)
            return Value.CompareTo(target) >= 0;
        return Value.CompareTo(target) <= 0;
    }

    public bool IsBetterThan(IEnumerable<T> targets)
    {
        foreach(var target in targets)
        {
            if (ComparisonType == ComparisonType.SmallerThan && Value.CompareTo(target) >= 0)
                return false;
            if (ComparisonType == ComparisonType.GreaterThan && Value.CompareTo(target) <= 0)
                return false;
        }
        return true;
    }

}

foreach(var property in GetType().GetProperties())
        {
            var t = property.GetType().GetInterfaces();
            if (!property.GetType().GetInterfaces().Contains(typeof(IComparableProperty))) continue;

            var compareTo = target.GetType().GetProperty(property.Name).GetValue(target, null) as IComparableProperty;
            var local = property.GetValue(this, null) as IComparableProperty;
            if (local == null) continue;
            if(!local.IsBetterThan(compareTo))
                return false;
        }

foreach (var property in GetType().GetProperties())
        {
            if (!typeof(IComparableProperty).IsAssignableFrom(property.PropertyType)) continue;

            var compareTo = target.GetType().GetProperty(property.Name).GetValue(target, null) as IComparableProperty;
            var local = property.GetValue(this, null) as IComparableProperty;
            if (local == null) continue;
            return local.IsBetterThan(compareTo);
        }

然后，似乎在接口中找不到IComparableProperty。我已经通过了可能包含它的主要方法。。。但是t包含的唯一接口是ICCustomAttribute Provider、\u MemberInfo、\u PropertyInfo和ISerializable

编辑2:

我已经通过使用

if (property.PropertyType.Name != "ComparableProperty`1") continue;

---

在将T更改为ComparableProperty并将IEnumerable更改为IEnumerable>之后，整个比较工作正常。

您可以创建一个非通用接口，然后使用它：

 public interface IComparableProperty
    {
        bool IsBetterThan(object target);

        bool IsBetterThan(IEnumerable targets);
    }

    public abstract class ComparableProperty<T>: IComparableProperty where T : IComparable<T>
    {
        T Value { get; set; }
        public ComparisonType ComparisonType { get; set; }
        public bool IsBetterThan(T target)
        {
            if (ComparisonType == ComparisonType.GreaterThan)
                return Value.CompareTo(target) >= 0;
            return Value.CompareTo(target) <= 0;
        }

        public bool IsBetterThan(IEnumerable<T> targets)
        {
            foreach (var target in targets)
            {
                if (ComparisonType == ComparisonType.SmallerThan && Value.CompareTo(target) >= 0)
                    return false;
                if (ComparisonType == ComparisonType.GreaterThan && Value.CompareTo(target) <= 0)
                    return false;
            }
            return true;
        }

        bool IComparableProperty.IsBetterThan(object target)
        {
            return IsBetterThan((T) target);
        }

        bool IComparableProperty.IsBetterThan(IEnumerable targets)
        {
            return IsBetterThan((IEnumerable<T>) (targets));
        }
    }

---

哦，天哪，当我不睡觉的时候，我似乎失去了50%的智力。这确实是解决方案，谢谢！我说得太快了。编辑OP澄清。对，答案在技术上仍然解决了我原来的问题，所以我会接受它。使用一个特定的接口确实做到了这一点，但如果我想使用强类型，我仍然需要找出其中的一部分：）

 public interface IComparableProperty
    {
        bool IsBetterThan(object target);

        bool IsBetterThan(IEnumerable targets);
    }

    public abstract class ComparableProperty<T>: IComparableProperty where T : IComparable<T>
    {
        T Value { get; set; }
        public ComparisonType ComparisonType { get; set; }
        public bool IsBetterThan(T target)
        {
            if (ComparisonType == ComparisonType.GreaterThan)
                return Value.CompareTo(target) >= 0;
            return Value.CompareTo(target) <= 0;
        }

        public bool IsBetterThan(IEnumerable<T> targets)
        {
            foreach (var target in targets)
            {
                if (ComparisonType == ComparisonType.SmallerThan && Value.CompareTo(target) >= 0)
                    return false;
                if (ComparisonType == ComparisonType.GreaterThan && Value.CompareTo(target) <= 0)
                    return false;
            }
            return true;
        }

        bool IComparableProperty.IsBetterThan(object target)
        {
            return IsBetterThan((T) target);
        }

        bool IComparableProperty.IsBetterThan(IEnumerable targets)
        {
            return IsBetterThan((IEnumerable<T>) (targets));
        }
    }

foreach (var property in GetType().GetProperties())
        {
            if (!typeof(IComparableProperty).IsAssignableFrom(property.PropertyType)) continue;

            var compareTo = target.GetType().GetProperty(property.Name).GetValue(target, null) as IComparableProperty;
            var local = property.GetValue(this, null) as IComparableProperty;
            if (local == null) continue;
            return local.IsBetterThan(compareTo);
        }