同一列表中的多个泛型类型并调用它们的方法

Question

我在业余时间制作一个对象验证框架来学习一些东西，并可能将它用于一些学校项目。

我有我的通用Rule类，它看起来像这样：

class Rule<T>
{
    string propertyName;
    Func<T, bool> ruleLambda;

    bool IsBroken(T value)
    {
        return ruleLambda(value);
    }
}

将被验证的对象看起来有点像这样：

class Example
{
    List<Rule<?>> MyRules; // can take all types of rules

    List<Rule<T>> Validate<T>(string propertyName, T value)
    {
        List<Rule<T>> brokenRules = new List<Rule<T>>();
        foreach (Rule rule in MyRules.Where(r => r.propertyName == propertyName))
        {
            if (rule.IsBroken(value))
                brokenRules.Add(rule);
        }
        return brokenRules;
    }
}

其中T value参数是Example类的一个属性的值，可以是任何类型。

只要设置了属性，就会调用Validate<T>方法。

问题在于班级的规则列表。 特别是上面的List<Rule<?>>行。 我想在同一个列表中存储给定类的所有规则。

唉，C＃没有像Java那样的通用类型的通配符。

我该怎么做？

使用对象而不是T的非泛型接口或基类可以工作，但是如何调用泛型规则的IsBroken方法而不是非泛型方法呢？

Answer 1

我将您的规则存储为Example类中的object ，并使用Enumerable.OfType<T>来查找给定类型的匹配规则：

class Example
{
    private List<object> rules;

    List<Rule<T>> Validate<T>(string propertyName, T value)
    {
        return this.rules.OfType<Rule<T>>()
            .Where(r => r.PropertyName == propertyName && r.IsBroken(value))
            .ToList();
    }
}

Answer 2

在我需要这样的东西的情况下，我使用接口或非泛型基类。 例如，您可以创建一个接口：

public interface IRule
{
  //non-generic properties & methods
}

public class Rule<T> : IRule
{
  //implementation
}

然后创建一个接口列表：

private List<IRule> MyRules;

如果要从界面转换为通用easy，可以添加扩展方法：

public static Rule<T> ToGeneric<T>(this IRule rule)
{
  return rule as Rule<T>;
}

Answer 3

我尝试了一些东西，并且我发现了一些适合我需求的东西。 我有一个Rule<T>从基本抽象规则类继承，使用通用的IsBroken方法：

abstract class Rule
{
    string propertyName;
    Func<object, bool> objectRule;

    bool IsBroken<T>(T value)
    {
        Rule<T> rule = this as Rule<T>;
        if (rule == null)
            return objectRule(value);

        return rule.IsBroken(value);
    }
}

如您所见，我尝试使用IsBroken方法中的泛型类型参数将基类转换为其通用对应项。

此外，在创建Rule<T>实例时，我将Func<object, bool>发送到其基类保护构造函数：

public Rule(string propertyName, Func<T, bool> ruleLambda)
    : base(propertyName, ConvertToObjectFunc(ruleLambda))
{
}

转换方法如下所示：

static Func<object, bool> ConvertToObjectFunc(Func<T, bool> func)
{
    return new Func<object, bool>(o => func((T)o));
}

但是，如果它无法将o转换为类型T，则会崩溃。 所以我写了这个...东西：

static Func<object, bool> ConvertToObjectFunc(Func<T, bool> func)
{
    return new Func<object, bool>
    (
        o =>
        {
            try
            {
                T obj = (T)o;
                return func(obj);
            }
            catch { return true; } // rule is broken by default
        }
    );
}

这很难看，但它确实有效。 希望这可以帮助其他人。