LINQ：具有 IQueryable 的泛型

Question

我必须向我的 C#.NET 应用程序添加一些“查找”查询。基本上，会有很多表都具有相同的模式，但包含不同的值。

我面临一遍又一遍地编写相同的代码（应该是一种 OO 方式来做到这一点..）

[编辑 - 下面被修改以显示更完整的信息] 无论如何，我想做的是：

public List<GenericLookupE>         GetLookupItems( string what )
{
    // create db thing
    if ( "regions" == what )  return FetchLookup( db.lkRegions.AsQueryable() );
    if ( "partners" == what ) return FetchLookup( db.lkPartners.AsQueryable() );
    if ( "funders" == what )  return FetchLookup( db.lkFunders.AsQueryable() );

    return null; // or something more intelligent than that =)
}


private List<GenericLookupE>        FetchLookup<T>( IQueryable<T> lookup )
{
    return lookup.OrderBy( p => p.Sequence ).Select
    (   p => new GenericLookupE()
        {
            ID      = p.ID
            ,Label      = p.Label
            ,StateCode  = p.StateCode
            ,Sequence   = p.Sequence
        }
    ).ToList();
}

当然，问题是编译器不知道'p => p.Sequence' 是什么。 有什么想法吗？

谢谢大家。

Answer 1

泛型的类型约束是你的朋友。使用包含序列的基类型或接口：

where T : IMyBaseInterface

http://msdn.microsoft.com/en-us/library/bb384067.aspx

Answer 2

为您的Т 类添加一个通用接口，在那里定义Sequence，并为您的泛型添加一个约束，要求Т 参数来实现通用接口。

interface ICommonInterface { // This is an awful name, please pick something better
    int Sequence { get }
}

private List<GenericLookupE> FetchLookup<T>( IQueryable<T> lookup ) where T : ICommonInterface {
    // Your stuff here
}

Answer 3

干净的解决方案是使用通用的基本类型或通用接口。

如果由于某种原因这是不可能的，这里有一种动态构造你想要的表达式的方法：

// Returns an expression of the form: p => new GenericLookupE
// { ID = p.ID, Label = p.Label, StateCode = p.StateCode, Sequence = p.Sequence }
// Can be written as a more generic 'auto-mapper', but
// this sample only solves your specific problem.
static Expression<Func<T, GenericLookupE>> GetLookupMapper<T>()
{ 
    var parameter = Expression.Parameter(typeof(T), "p");

    string[] properties = { "ID", "Label", "StateCode", "Sequence" };

    var bindings = from propName in properties
                   let source = Expression.Property(parameter, propName)
                   let target = typeof(GenericLookupE).GetProperty(propName)
                   select Expression.Bind(target, source);    

    var newExp = Expression.New(typeof(GenericLookupE));    
    var body = Expression.MemberInit(newExp, bindings);

    return Expression.Lambda<Func<T, GenericLookupE>>(body, parameter);
}

然后你的方法就变成了：

private List<GenericLookupE> FetchLookup<T>(IQueryable<T> lookup)
{
    return lookup.Select(GetLookupMapper<T>())
                 .OrderBy(p => p.Sequence)
                 .ToList();
}

我真的怀疑你是否需要这样的东西。

Answer 4

您的对象Regions、Partners 和Funders 似乎具有相同的一组属性（ID、Label、StateCode 和Sequence）。这通常称为“鸭子打字”。

但是，要编写一个适用于所有这些的“通用”强类型解决方案，它们都必须从列出这些属性的通用接口或基类型派生！

我看到以下 3 个解决方案：

1. 使Regions、Partners和Funders继承一个基类型（如GenericLookupE），或使它们实现一个通用接口（如IGenericLookupE）。
   • 如果这些类是为您生成的，那么可能很难做到这一点
   • 如果您能做到这一点，那么您只需 .Cast 到正确的类型，而无需 Selecting 新对象（查看更新）
2. 使用dynamic 类型或反射来获取属性（类型松散，但可以工作）
3. 为每种类型创建一次性解决方案（这基本上是您要避免的）

更新

以下是一些使您的数据库对象实现通用接口的方法，具体取决于您的框架：

Adding a Base Class (or Interface) to All LINQ to SQL Entities

Implementing an interface on a LINQ to SQL object using a partial class