如何将实体框架包含扩展方法引入通用 IQueryable

发布于 2024-11-25 20:11:06 字数 805 浏览 6 评论 0原文

事情是这样的。

我有一个接口，我会将属于 EntityFramework 库的 Include 扩展方法放入我不需要的 IRepository 层了解EntityFramework。

public interface IRepository<TEntity>
{
    IQueryable<TEntity> Entities { get; }

    TEntity GetById(long id);
    TEntity Insert(TEntity entity);
    void Update(TEntity entity);
    void Delete(TEntity entity);
    void Delete(long id);
}

所以我有扩展方法：

public static class IncludeExtension 
{
    static IQueryable<TEntity> Include<TEntity>(this IQueryable<TEntity> query, 
        string path)
    {
        throw new NotImplementedException();
    }
}

但我不知道如何在这一层实现它，我会将它发送到我的EntityFramework（或任何将实现IRepository的人）来处理。

我需要同样的具有扩展方法的接口。

有光吗？

原文

Here's the thing.

I have an interface, and I would to put the Include extension method, who belongs to EntityFramework library, to my IRepository layer wich dont needs to knows about EntityFramework.

public interface IRepository<TEntity>
{
    IQueryable<TEntity> Entities { get; }

    TEntity GetById(long id);
    TEntity Insert(TEntity entity);
    void Update(TEntity entity);
    void Delete(TEntity entity);
    void Delete(long id);
}

So I have the extension method:

public static class IncludeExtension 
{
    static IQueryable<TEntity> Include<TEntity>(this IQueryable<TEntity> query, 
        string path)
    {
        throw new NotImplementedException();
    }
}

But I don't know how to implement it in this layer, and I would to send it to my EntityFramework (or whatever who will implement the IRepository) to deal with.

I need same to a Interface with a extension method.

Any light?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

半透明的墙 2024-12-02 20:11:06

Include 是有漏洞的抽象，它仅适用于实体框架。 EF 4.1 已包含 包含在通用IQueryable上，但它在内部仅将传递的通用IQueryable转换为通用ObjectQuery或DbQuery 并调用它们的Include。

以下是如何包装包含在存储库中（存储库实现依赖于 EF，因此可以直接使用 EF 提供的 Include）。

回复收藏 0 原文

古镇旧梦 2024-12-02 20:11:06

这个问题有点老了，但如果您或其他人仍在寻找，这里有两个独立于 EF 的解决方案：

1。基于反射的解决方案

如果 IQueryable 未转换为 DbQuery 或 ObjectQuery，.NET Framework 会采用此解决方案。 >。跳过这些转换（及其提供的效率），您就可以将解决方案与实体框架解耦。

public static class IncludeExtension  
{ 
    private static T QueryInclude<T>(T query, string path) 
    { 
        MethodInfo includeMethod = query.GetType().GetMethod("Include", new Type[] { typeof(string) });

        if ((includeMethod != null) && typeof(T).IsAssignableFrom(includeMethod.ReturnType))
        {
           return (T)includeMethod.Invoke(query, new object[] { path });
        }

        return query;
    }

    public static IQueryable<T> Include<T>(this IQueryable<T> query, string path) where T : class
    {
        return QueryInclude(query, path);
    }

    // Add other Include overloads.
}

2.基于动态的解决方案

这里，QueryInclude 方法使用dynamic 类型来避免反射。

public static class IncludeExtension  
{ 
    private static T QueryInclude<T>(T query, string path) 
    { 
        dynamic querytWithIncludeMethod = query as dynamic;

        try
        {
            return (T)querytWithIncludeMethod.Include(path);
        }
        catch (RuntimeBinderException)
        {
            return query;
        }
    }

    public static IQueryable<T> Include<T>(this IQueryable<T> query, string path) where T : class
    {
        return QueryInclude(query, path);
    }

    // Add other Include overloads.
}

This question is a bit old, but here are two EF-independent solutions if you or anyone else is still looking:

1. Reflection-based Solution

This solution is what the .NET Framework falls back to if the IQueryable does not cast to a DbQuery or ObjectQuery. Skip these casts (and the efficiency it provides) and you've decoupled the solution from Entity Framework.

public static class IncludeExtension  
{ 
    private static T QueryInclude<T>(T query, string path) 
    { 
        MethodInfo includeMethod = query.GetType().GetMethod("Include", new Type[] { typeof(string) });

        if ((includeMethod != null) && typeof(T).IsAssignableFrom(includeMethod.ReturnType))
        {
           return (T)includeMethod.Invoke(query, new object[] { path });
        }

        return query;
    }

    public static IQueryable<T> Include<T>(this IQueryable<T> query, string path) where T : class
    {
        return QueryInclude(query, path);
    }

    // Add other Include overloads.
}

2. Dyanmics-based Solution

Here the QueryInclude<T> method uses the dynamic type to avoid reflection.

public static class IncludeExtension  
{ 
    private static T QueryInclude<T>(T query, string path) 
    { 
        dynamic querytWithIncludeMethod = query as dynamic;

        try
        {
            return (T)querytWithIncludeMethod.Include(path);
        }
        catch (RuntimeBinderException)
        {
            return query;
        }
    }

    public static IQueryable<T> Include<T>(this IQueryable<T> query, string path) where T : class
    {
        return QueryInclude(query, path);
    }

    // Add other Include overloads.
}

回复收藏 0 原文