C# 寻找在基类中实现函数的通用方法

我正在尝试在我的域层中对规范模式进行一个简单的实现

如果我有一个静态类，里面有这样的规范：

public static class FooSpecifications
{
  public static Func<Foo, bool> IsSuperhuman
  {
    get
    {
      return foo => foo.CanShootLasersOutOfItsEyes && foo.CanFly;
    }
  }
}

IEnumerable<Foo> foos = GetAllMyFoos();
var superFoos = foos.Where(FooSpecifications.IsSuperhuman);

公共静态类规范
{
公共静态函数
{
得到
{
return foo=>foo.CanShootLasersOutOfItsEyes&&foo.CanFly；
}
}
}

然后我就可以做这样奇妙的事情：

public static class FooSpecifications
{
  public static Func<Foo, bool> IsSuperhuman
  {
    get
    {
      return foo => foo.CanShootLasersOutOfItsEyes && foo.CanFly;
    }
  }
}

IEnumerable<Foo> foos = GetAllMyFoos();
var superFoos = foos.Where(FooSpecifications.IsSuperhuman);

IEnumerable foos=GetAllMyFoos（）；
var superFoos=foos.Where（foosspecifications.IsSuperhuman）；

我还可以将bool方法添加到Foo中，以确定特定实例是否符合规范：

public bool Meets(Func<Foo, bool> specification)
{
  return specification.Invoke(this);
}

public bool符合（Func规范）
{
返回规范.Invoke（this）；
}

考虑到Foo和我所有的域实体一样，扩展了DomainObject，有没有一种方法可以将Meets（）的通用实现放在DomainObject中，以将我在每个实体中分别实现Meets（）保存起来？

类似这样的东西

    public abstract class DomainObj<T> // T - derived type
        where T : DomainObj<T>
    {
        public bool Meets(Func<T, bool> specification)
        {
            return specification.Invoke((T) this);
        }
    }

    public class Foo : DomainObj<Foo> {}

    public class Bar : DomainObj<Bar> {}       

        Func<Foo, bool> foospec = x => true;
        Func<Bar, bool> barspec = x => true;

        var foo = new Foo();
        var bar = new Bar();
        foo.Meets(foospec);
        foo.Meets(barspec); // won't compile because of mismatched types of spec and object instance

公共抽象类DomainObj//T-派生类型
其中T:DomainObj
{
公共布尔满足（Func规范）
{
返回规范。调用（（T）this）；
}
}
公共类Foo:DomainObj{}
公共类栏：DomainObj{}
Func foospec=x=>true；
Func barspec=x=>true；
var foo=new foo（）；
var bar=新的bar（）；
foo.Meets（foospec）；
foo.Meets（barspec）；//无法编译，因为等级库和对象实例的类型不匹配

编辑

也许将Meet方法转换为extension会更好。这将消除对类型参数的需要

    public abstract class DomainObj
    {
    }

    public static class DomainObjExtensions
    {
        public static bool Meets<T>(this T obj, Func<T, bool> f)
            where T : DomainObj
        {
            return f(obj);
        }
    }

    public class Foo : DomainObj {}

    public class Bar : DomainObj {}

    Func<Foo, bool> foospec = x => true;
    Func<Bar, bool> barspec = x => true;

    var foo = new Foo();
    var bar = new Bar();
    foo.Meets(foospec);
    foo.Meets(barspec); // error

公共抽象类DomainObj
{
}
公共静态类DomainObjExtensions
{
公共静态布尔满足（本目标，函数f）
其中T:DomainObj
{
返回f（obj）；
}
}
公共类Foo:DomainObj{}
公共类栏：DomainObj{}
Func foospec=x=>true；
Func barspec=x=>true；
var foo=new foo（）；
var bar=新的bar（）；
foo.Meets（foospec）；
foo.Meets（barspec）；//错误

提示：您可以使用Predicate而不是Func。@Paul：可以，但是在框架的最新版本中，尤其是LINQ中，趋势是使用

Func

而不是

Predicate

。@LukeH:很有趣，我不知道这一点（显然）谢谢。派生类声明之后的大括号是什么？当我把它们放进去时，我开始得到“名称空间不能包含成员”的编译器错误。不管怎样，在派生类中，编译器都不能识别DomainObject类型，即使它们在同一名称空间中。我的缺点：我粘贴了一些代码，但没有注意到您使用的是DomainObj而不是DomainObject。这似乎可行，但现在我遇到了另一个问题。如何将派生类型强制转换回DomainObject？对不起，我的意思不是将派生类型强制转换为DomainObject，而是将对象强制转换为DomainObject。