Question

我正在尝试在我的对象模型上创建某种通用过滤系统，以允许＆＃34; staged＆＃34;调用

考虑以下表示数据库中数据的模型类。

class MyClass
{
    public string PropertyA {get; set;}
    public string PropertyB {get; set;}
    public string PropertyC {get; set;}
    public string PropertyD {get; set;}
    public string PropertyE {get; set;}
}

然后我有一个DAL来检索数据..

public class MyClassDAL()
{
    public static List<MyClass> GetAllRequests()
    {
        List<MyClass> lst = new List<MyClass>();
        using (MyDBContext cntx = new MyDBContext())
        {
            lst = cntx.MyTable.ToList();
        }
        return (lst);
    }
}

在我的应用程序的许多方面，我需要能够检索这些数据，但根据请求在应用程序中的位置，我希望能够过滤任何模型属性。

现在，我可以传入参数，或设置大量重载方法，但我想知道是否有更优雅的代码可读＆＃34;这样做的方法..

像...一样的东西。

MyClassDAL.GetAllRequests().ForPropA("x")
                           .ForPropC("y")
                           .ForPropE("z")

当然，我可以在任何需要的地方使用LINQ Where Lambdas，但我正在寻找更多的东西＆＃34;整洁＆＃34;

Answer 1

如果你使用linq Where函数，你只需要为它提供一个合适的表达式，它不必是一个匿名函数。您可以定义自己的方法，如下所示：

    public static Expression<Func<MyEntity, bool>> NameIs(string name)
    {
        return e => e.Name == name;
    }

...然后像这样调用它：

    var x = context.MyEntities.Where(NameIs("foo"));

或者，您可以使用扩展方法来摆脱Where部分：

    public static IQueryable<MyEntity> WhereNameIs(
        this IQueryable<MyEntity> entities,
        string name)
    {
        return entities.Where(e => e.Name == name);
    }

...你可以称之为：

    var x = context.MyEntities.WhereNameIs("foo");

Answer 2

您可以自定义此排序解决方案，该解决方案非常适合做空。您需要传递参数，而泛型方法将会休息。

class Program
{
    static void Main(string[] args)
    {
        // Data source
        List<Student> students = new List<Student>();
        students.Add(new Student { Id = 1, Name = "A" });
        students.Add(new Student { Id = 2, Name = "B" });
        students.Add(new Student { Id = 3, Name = "A" });
        students.Add(new Student { Id = 4, Name = "D" });

        // Apply Sorting
        var sorttedStudents = students.AsQueryable().ApplySort("id");
        var sorttedStudents1 = students.AsQueryable().ApplySort("-id");
        var sorttedStudents2 = students.AsQueryable().ApplySort("-name,id");

        Console.ReadKey();
    }
}

public static class IQueryableApplyFilterExtension
{
    public static IQueryable<T> ApplySort<T>(this IQueryable<T> source, string key)
    {
        if (source == null)
        {
            throw new ArgumentNullException("source", "Data source is empty.");
        }

        if (key == null)
        {
            return source;
        }

        var lstSort = key.Split(',');

        string sortExpression = string.Empty;

        foreach (var sortOption in lstSort)
        {
            if (sortOption.StartsWith("-"))
            {
                sortExpression = sortExpression + sortOption.Remove(0, 1) + " descending,";
            }
            else
            {
                sortExpression = sortExpression + sortOption + ",";
            }
        }

        if (!string.IsNullOrWhiteSpace(sortExpression))
        {
            // Note: Install-Package: system.linq.dynamic NuGet package is required here to operate OrderBy on string
            // Then use using System.Linq.Dynamic; namespace
            source = source.OrderBy(sortExpression.Remove(sortExpression.Count() - 1));
        }

        return source;
    }
}

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
}

希望这有帮助。

通过方法调用列出过滤

2 个答案: