C# 在IQueryable中搜索<；对象>；

可以在IQueryable中搜索吗

public static IQueryable<object> SearchAllFields(IQueryable<object> query, string term)
{
    query = query.Where(q => q.Property1 == term);
    query = query.Where(q => q.Property2 == term);
    query = query.Where(q => q.Property3 == term);

    return query;
}

---

您可以使用反射来搜索元素的所有属性，但如果要返回任何属性匹配的所有行，则需要使用predicatebuilder来构建应用的查询，而不是where（）

这个示例代码将返回两个Foo实例，其中A、B和C都是“A”。以及其中E、F和G为“a”的Bar实例。还添加了匿名类型的示例

class Program
{
    private class Foo
    {
        public string A { get; set; }
        public string B { get; set; }
        public string C { get; set; }
    }

    private class Bar
    {
        public string E { get; set; }
        public string F { get; set; }
        public string G { get; set; }
    }

    static void Main(string[] args)
    {
        var list = new List<Foo>
        {
            new Foo { A = "a", B = "a", C = "a" },
            new Foo { A = "a2", B = "b2", C = "c2" },
            new Foo { A = "a3", B = "b3", C = "c3" },
        };
        var list2 = new List<Bar>
        {
            new Bar { E = "a", F = "a", G = "a" },
            new Bar { E = "a2", F = "b2", G = "c2" },
            new Bar { E = "a3", F = "b3", G = "c3" },
        };

        var q1 = Filter(list.AsQueryable(), "a");
        var q2 = Filter(list2.AsQueryable(), "a");

        foreach (var x in q1)
        {
            Console.WriteLine(x);
        }

        foreach (var x in q2)
        {
            Console.WriteLine(x);
        }

        var queryable = list.Select(p => new
        {
            X = p.A,
            Y = p.B,
            Z = p.C
        }).AsQueryable();
        var q3 = Filter(queryable, "a"); 
        foreach (var x in q3)
        {
            Console.WriteLine(x);
        }

        Console.ReadKey();
    }

    private static IQueryable<object> Filter(IQueryable<object> list, string value)
    {
        foreach (var prop in list.ElementType.GetProperties())
        {
            var prop1 = prop;
            list = list.Where(l => Equals(prop1.GetValue(l, null), value));
        }

        return list;
    }
}

类程序
{
私家班
{
公共字符串A{get；set；}
公共字符串B{get；set；}
公共字符串C{get；set；}
}
私人酒吧
{
公共字符串E{get；set；}
公共字符串F{get；set；}
公共字符串G{get；set；}
}
静态void Main（字符串[]参数）
{
变量列表=新列表
{
新的Foo{A=“A”，B=“A”，C=“A”}，
新的Foo{A=“a2”，B=“b2”，C=“c2”}，
新的Foo{A=“a3”，B=“b3”，C=“c3”}，
};
var list2=新列表
{
新条{E=“a”，F=“a”，G=“a”}，
新条{E=“a2”，F=“b2”，G=“c2”}，
新条{E=“a3”，F=“b3”，G=“c3”}，
};
var q1=过滤器（list.AsQueryable（），“a”）；
var q2=过滤器（list2.AsQueryable（），“a”）；
foreach（第一季度的var x）
{
控制台写入线（x）；
}
foreach（第二季度的var x）
{
控制台写入线（x）；
}
var queryable=list.Select（p=>new
{
X=p.A，
Y=p.B，
Z=p.C
}).AsQueryable（）；
var q3=过滤器（可查询，“a”）；
foreach（第三季度的风险值x）
{
控制台写入线（x）；
}
Console.ReadKey（）；
}
专用静态IQueryable筛选器（IQueryable列表，字符串值）
{
foreach（list.ElementType.GetProperties（）中的var prop）
{
var prop1=prop；
list=list.Where（l=>Equals（prop1.GetValue（l，null），value））；
}
退货清单；
}
}

您可以使用

IQuerable

来代替，但如果它是由linqtosql或EF支持的，我会感到惊讶。你在查询什么？几秒钟后会有一个“使用

IQueryable

”的答案，但正确的答案很可能是“使用接口，这样你就可以查询

IQueryable

”。谢谢你，乔恩你能把你的例子扩大一点吗？例如，您是否有

Book.Author

或

Paper.PublisherName

或

Class.TeacherName

，并且要搜索其中一个名称？在这种情况下，顺便说一下，接口将不会有帮助，因为EF无法处理属性中的代码-您必须更改映射。（这里EF只是一个假设，基于

IQueryable

）您何时知道要基于哪些属性进行查询？对我来说，这个问题的答案是一个好的解决方案的关键。你不能在没有枚举的情况下搜索IQueryable，但你可以在枚举之前向该查询添加“查询”，例如，如果您有myQuery，您可以执行myQuery.Where（表达式），其中表达式类似于x=>x==yNice！我想我还是会使用

IQueryable过滤器（IQueryable

）和

typeof（T）

而不是

list.ElementType

。另外，你确定要使用

object.Equals

？这看起来有点奇怪。另外，仔细阅读问题，OP可能只希望其中一个属性等于

value

，而不是所有属性。但这实际上是在字里行间阅读，问题不是我不清楚……是的，这是predicatebuilder来做OR查询的。显然，参数和属性类型不匹配会有问题，但总的想法是存在的。@JanneMatikainen-嘿，我一直计划使用谓词生成器来链接

或
语句，如果我能得到一个正常的
Where
到谢谢你的意见。
query = DataTableHelper.SearchAllFields(query, pageRequest.Search);

class Program
{
    private class Foo
    {
        public string A { get; set; }
        public string B { get; set; }
        public string C { get; set; }
    }

    private class Bar
    {
        public string E { get; set; }
        public string F { get; set; }
        public string G { get; set; }
    }

    static void Main(string[] args)
    {
        var list = new List<Foo>
        {
            new Foo { A = "a", B = "a", C = "a" },
            new Foo { A = "a2", B = "b2", C = "c2" },
            new Foo { A = "a3", B = "b3", C = "c3" },
        };
        var list2 = new List<Bar>
        {
            new Bar { E = "a", F = "a", G = "a" },
            new Bar { E = "a2", F = "b2", G = "c2" },
            new Bar { E = "a3", F = "b3", G = "c3" },
        };

        var q1 = Filter(list.AsQueryable(), "a");
        var q2 = Filter(list2.AsQueryable(), "a");

        foreach (var x in q1)
        {
            Console.WriteLine(x);
        }

        foreach (var x in q2)
        {
            Console.WriteLine(x);
        }

        var queryable = list.Select(p => new
        {
            X = p.A,
            Y = p.B,
            Z = p.C
        }).AsQueryable();
        var q3 = Filter(queryable, "a"); 
        foreach (var x in q3)
        {
            Console.WriteLine(x);
        }

        Console.ReadKey();
    }

    private static IQueryable<object> Filter(IQueryable<object> list, string value)
    {
        foreach (var prop in list.ElementType.GetProperties())
        {
            var prop1 = prop;
            list = list.Where(l => Equals(prop1.GetValue(l, null), value));
        }

        return list;
    }
}