C# LINQ：查询上的Foreach循环导致意外结果_C#_Asp.net Mvc_Linq

C# LINQ：查询上的Foreach循环导致意外结果

c# asp.net-mvc linq

C# LINQ：查询上的Foreach循环导致意外结果,c#,asp.net-mvc,linq,C#,Asp.net Mvc,Linq,所以我有一个查询，如果查询中有一个匹配的单词与名字、姓氏或电话号码中的任何一个匹配，它应该返回一条记录： var searchWords = searchQuery .Split(' ') .Select(x => x.Trim() .ToLower()) .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray(

所以我有一个查询，如果查询中有一个匹配的单词与名字、姓氏或电话号码中的任何一个匹配，它应该返回一条记录：

var searchWords = searchQuery
                .Split(' ')
                .Select(x => x.Trim()
                .ToLower())
                .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray();

foreach (var searchWord in searchWords)
        {
            var word = searchWord;
            someParentObjects= someParentObjects
            .Where(x => x.User.FirstName.ToLower().Contains(word) ||
            x.User.LastName.ToLower().Contains(word) ||
            x.User.CellPhone.Contains(word) 
            );
        }

不知何故，contains匹配不起作用，因此我得到的结果为零？为什么呢

注意：第一部分工作正常，我可以从searchQuery中获得经过修剪的单词

测试数据：

基本上我想做的就是根据查询过滤结果。如果查询中有任何单词与名字、姓氏或手机中的任何一个匹配，我将返回这些记录。因此，如果我在数据库中有一条记录，名字是“James”，姓氏是“Brian”，如果我以“jamessomething”的形式传递查询，它应该返回一条记录。但它不会回来。我没有任何记录

您的代码基本上过滤了至少一个字段中存在的所有“搜索词”。对于多个单词，这种过滤很可能不会返回任何结果

您的

foreach

搜索词“Bob John”和患者“John Doe”的简化版本：

虽然不清楚您在寻找什么，但可能会在第一个非空结果时停止，这是一个选项：

    foreach (var searchWord in searchWords)
    {
        var word = searchWord;
        var filteredPatientSteps = patientSteps
        .Where(x => x.User.FirstName.ToLower().Contains(word) ||
        x.User.LastName.ToLower().Contains(word) ||
        x.User.CellPhone.Contains(word) 
        );
        if (filteredPatientSteps.Any())
        {
             // jump out on first match 
            patientSteps = filteredPatientSteps;
            break;
         }
    }

您的代码基本上过滤了至少一个字段中存在的所有“搜索词”。对于多个单词，这种过滤很可能不会返回任何结果

您的

foreach

搜索词“Bob John”和患者“John Doe”的简化版本：

虽然不清楚您在寻找什么，但可能会在第一个非空结果时停止，这是一个选项：

    foreach (var searchWord in searchWords)
    {
        var word = searchWord;
        var filteredPatientSteps = patientSteps
        .Where(x => x.User.FirstName.ToLower().Contains(word) ||
        x.User.LastName.ToLower().Contains(word) ||
        x.User.CellPhone.Contains(word) 
        );
        if (filteredPatientSteps.Any())
        {
             // jump out on first match 
            patientSteps = filteredPatientSteps;
            break;
         }
    }

您的代码基本上过滤了至少一个字段中存在的所有“搜索词”。对于多个单词，这种过滤很可能不会返回任何结果

您的

foreach

搜索词“Bob John”和患者“John Doe”的简化版本：

虽然不清楚您在寻找什么，但可能会在第一个非空结果时停止，这是一个选项：

    foreach (var searchWord in searchWords)
    {
        var word = searchWord;
        var filteredPatientSteps = patientSteps
        .Where(x => x.User.FirstName.ToLower().Contains(word) ||
        x.User.LastName.ToLower().Contains(word) ||
        x.User.CellPhone.Contains(word) 
        );
        if (filteredPatientSteps.Any())
        {
             // jump out on first match 
            patientSteps = filteredPatientSteps;
            break;
         }
    }

您的代码基本上过滤了至少一个字段中存在的所有“搜索词”。对于多个单词，这种过滤很可能不会返回任何结果

您的

foreach

搜索词“Bob John”和患者“John Doe”的简化版本：

虽然不清楚您在寻找什么，但可能会在第一个非空结果时停止，这是一个选项：

    foreach (var searchWord in searchWords)
    {
        var word = searchWord;
        var filteredPatientSteps = patientSteps
        .Where(x => x.User.FirstName.ToLower().Contains(word) ||
        x.User.LastName.ToLower().Contains(word) ||
        x.User.CellPhone.Contains(word) 
        );
        if (filteredPatientSteps.Any())
        {
             // jump out on first match 
            patientSteps = filteredPatientSteps;
            break;
         }
    }

您没有提供足够的代码来创建复制，但是如果我填写其余的代码，您现有的代码似乎可以工作

void Main() {
    string searchQuery = "foo bar";
    IEnumerable<PatientStep> patientSteps = new PatientStep[] {
        new PatientStep("foo", "bar", "12345"),
        new PatientStep("foo", "williams", "12345"),
        new PatientStep("nancy", "bar", "12345"),
        new PatientStep("nothing", "relevant", "12345"),
    };

    var searchWords = searchQuery
                    .Split(' ')
                    .Select(x => x.Trim()
                        .ToLower())
                    .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray();

    foreach (var searchWord in searchWords) {
        var word = searchWord;
        patientSteps = patientSteps.Where(
            x => x.User.FirstName.ToLower().Contains(word)
                || x.User.LastName.ToLower().Contains(word)
                || x.User.CellPhone.Contains(word)
        );
    }

    foreach (var patientStep in patientSteps) {
        Console.WriteLine(patientStep.ToString());
    }
}

class PatientStep {
    public User User { get; private set; }

    public PatientStep(string first, string last, string cell) {
        this.User = new User { FirstName = first, LastName = last, CellPhone = cell };
    }

    public override string ToString() {
        return string.Format("{0} {1}, {2}", this.User.FirstName, this.User.LastName, this.User.CellPhone);
    }
}

class User {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string CellPhone { get; set; }
}

您没有提供足够的代码来创建复制，但是如果我填写其余的代码，您现有的代码似乎可以工作

void Main() {
    string searchQuery = "foo bar";
    IEnumerable<PatientStep> patientSteps = new PatientStep[] {
        new PatientStep("foo", "bar", "12345"),
        new PatientStep("foo", "williams", "12345"),
        new PatientStep("nancy", "bar", "12345"),
        new PatientStep("nothing", "relevant", "12345"),
    };

    var searchWords = searchQuery
                    .Split(' ')
                    .Select(x => x.Trim()
                        .ToLower())
                    .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray();

    foreach (var searchWord in searchWords) {
        var word = searchWord;
        patientSteps = patientSteps.Where(
            x => x.User.FirstName.ToLower().Contains(word)
                || x.User.LastName.ToLower().Contains(word)
                || x.User.CellPhone.Contains(word)
        );
    }

    foreach (var patientStep in patientSteps) {
        Console.WriteLine(patientStep.ToString());
    }
}

class PatientStep {
    public User User { get; private set; }

    public PatientStep(string first, string last, string cell) {
        this.User = new User { FirstName = first, LastName = last, CellPhone = cell };
    }

    public override string ToString() {
        return string.Format("{0} {1}, {2}", this.User.FirstName, this.User.LastName, this.User.CellPhone);
    }
}

class User {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string CellPhone { get; set; }
}

您没有提供足够的代码来创建复制，但是如果我填写其余的代码，您现有的代码似乎可以工作

void Main() {
    string searchQuery = "foo bar";
    IEnumerable<PatientStep> patientSteps = new PatientStep[] {
        new PatientStep("foo", "bar", "12345"),
        new PatientStep("foo", "williams", "12345"),
        new PatientStep("nancy", "bar", "12345"),
        new PatientStep("nothing", "relevant", "12345"),
    };

    var searchWords = searchQuery
                    .Split(' ')
                    .Select(x => x.Trim()
                        .ToLower())
                    .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray();

    foreach (var searchWord in searchWords) {
        var word = searchWord;
        patientSteps = patientSteps.Where(
            x => x.User.FirstName.ToLower().Contains(word)
                || x.User.LastName.ToLower().Contains(word)
                || x.User.CellPhone.Contains(word)
        );
    }

    foreach (var patientStep in patientSteps) {
        Console.WriteLine(patientStep.ToString());
    }
}

class PatientStep {
    public User User { get; private set; }

    public PatientStep(string first, string last, string cell) {
        this.User = new User { FirstName = first, LastName = last, CellPhone = cell };
    }

    public override string ToString() {
        return string.Format("{0} {1}, {2}", this.User.FirstName, this.User.LastName, this.User.CellPhone);
    }
}

class User {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string CellPhone { get; set; }
}

您没有提供足够的代码来创建复制，但是如果我填写其余的代码，您现有的代码似乎可以工作

void Main() {
    string searchQuery = "foo bar";
    IEnumerable<PatientStep> patientSteps = new PatientStep[] {
        new PatientStep("foo", "bar", "12345"),
        new PatientStep("foo", "williams", "12345"),
        new PatientStep("nancy", "bar", "12345"),
        new PatientStep("nothing", "relevant", "12345"),
    };

    var searchWords = searchQuery
                    .Split(' ')
                    .Select(x => x.Trim()
                        .ToLower())
                    .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray();

    foreach (var searchWord in searchWords) {
        var word = searchWord;
        patientSteps = patientSteps.Where(
            x => x.User.FirstName.ToLower().Contains(word)
                || x.User.LastName.ToLower().Contains(word)
                || x.User.CellPhone.Contains(word)
        );
    }

    foreach (var patientStep in patientSteps) {
        Console.WriteLine(patientStep.ToString());
    }
}

class PatientStep {
    public User User { get; private set; }

    public PatientStep(string first, string last, string cell) {
        this.User = new User { FirstName = first, LastName = last, CellPhone = cell };
    }

    public override string ToString() {
        return string.Format("{0} {1}, {2}", this.User.FirstName, this.User.LastName, this.User.CellPhone);
    }
}

class User {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string CellPhone { get; set; }
}

你的搜索词数组中有“James”吗？？您的代码似乎很好。如果searchQuery包含一个类似“jamesjohndoe”的字符串，那么searchWords的第一个元素将是“James”，其余的似乎都可以。我对此感到厌倦，因为：

var searchQuery = "John Doe Brazil";

            var searchWords = searchQuery
                .Split(' ')
                .Select(x => x.Trim()
                    .ToLower())
                .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray();
            User obj=new User()
            {
                FirstName = "Ali",
                LastName = "John"
            };
            var someParentObjects =new[]{ new Parent(){Users =obj}};


            foreach (var searchWord in searchWords)
            {
                var word = searchWord;
              var ParentObjects = someParentObjects
                .Where(x => x.Users.FirstName.ToLower().Contains(word) ||
                x.Users
                .LastName.ToLower().Contains(word) 

                );
            }

我将用户和家长视为：

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class Parent
{
    public User Users { get; set; }
    public Parent() { }

}

本例中的ParentObjects返回对象Ali John

编辑： 要使用ParentObjects外部循环，请执行以下操作：

List<Parent> ParentObjects=new List<Parent>();

            foreach (var searchWord in searchWords)
            {
                var word = searchWord;
               var ParentObject = someParentObjects.FirstOrDefault(x => x.Users.FirstName.ToLower().Contains(word) ||
                                                                        x.Users
                                                                            .LastName.ToLower().Contains(word));
                if(ParentObject!=null)
                ParentObjects.Add(ParentObject);
            }

List ParentObjects=new List（）；
foreach（searchWords中的var searchWord）
{
var-word=搜索词；
var ParentObject=someParentObjects.FirstOrDefault（x=>x.Users.FirstName.ToLower（）.Contains（word）||
x、 使用者
.LastName.ToLower（）.Contains（word））；
if（ParentObject！=null）
ParentObjects.Add（ParentObject）；
}

然后可以在循环之外使用ParentObjects。

您的搜索词数组中有“James”吗？？您的代码似乎很好。如果searchQuery包含一个类似“jamesjohndoe”的字符串，那么searchWords的第一个元素将是“James”，其余的似乎都可以。我对此感到厌倦，因为：

var searchQuery = "John Doe Brazil";

            var searchWords = searchQuery
                .Split(' ')
                .Select(x => x.Trim()
                    .ToLower())
                .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray();
            User obj=new User()
            {
                FirstName = "Ali",
                LastName = "John"
            };
            var someParentObjects =new[]{ new Parent(){Users =obj}};


            foreach (var searchWord in searchWords)
            {
                var word = searchWord;
              var ParentObjects = someParentObjects
                .Where(x => x.Users.FirstName.ToLower().Contains(word) ||
                x.Users
                .LastName.ToLower().Contains(word) 

                );
            }

我将用户和家长视为：

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class Parent
{
    public User Users { get; set; }
    public Parent() { }

}

本例中的ParentObjects返回对象Ali John

编辑： 要使用ParentObjects外部循环，请执行以下操作：

List<Parent> ParentObjects=new List<Parent>();

            foreach (var searchWord in searchWords)
            {
                var word = searchWord;
               var ParentObject = someParentObjects.FirstOrDefault(x => x.Users.FirstName.ToLower().Contains(word) ||
                                                                        x.Users
                                                                            .LastName.ToLower().Contains(word));
                if(ParentObject!=null)
                ParentObjects.Add(ParentObject);
            }

List ParentObjects=new List（）；
foreach（searchWords中的var searchWord）
{
var-word=搜索词；
var ParentObject=someParentObjects.FirstOrDefault（x=>x.Users.FirstName.ToLower（）.Contains（word）||
x、 使用者
.LastName.ToLower（）.Contains（word））；
if（ParentObject！=null）
ParentObjects.Add（ParentObject）；
}

然后可以在循环之外使用ParentObjects。

var searchQuery = "John Doe Brazil";

            var searchWords = searchQuery
                .Split(' ')
                .Select(x => x.Trim()
                    .ToLower())
                .Where(y => !string.IsNullOrWhiteSpace(y)).ToArray();
            User obj=new User()
            {
                FirstName = "Ali",
                LastName = "John"
            };
            var someParentObjects =new[]{ new Parent(){Users =obj}};


            foreach (var searchWord in searchWords)
            {
                var word = searchWord;
              var ParentObjects = someParentObjects
                .Where(x => x.Users.FirstName.ToLower().Contains(word) ||
                x.Users
                .LastName.ToLower().Contains(word) 

                );
            }

我将用户和家长视为：

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class Parent
{
    public User Users { get; set; }
    public Parent() { }

}

本例中的ParentObjects返回对象Ali John

编辑： 要使用ParentObjects外部循环，请执行以下操作：

List<Parent> ParentObjects=new List<Parent>();

            foreach (var searchWord in searchWords)
            {
                var word = searchWord;
               var ParentObject = someParentObjects.FirstOrDefault(x => x.Users.FirstName.ToLower().Contains(word) ||
                                                                        x.Users
                                                                            .LastName.ToLower().Contains(word));
                if(ParentObject!=null)
                ParentObjects.Add(ParentObject);
            }

List ParentObjects=new List（）；
foreach（searchWords中的var searchWord）
{
var-word=搜索词；
var ParentObject=someParentObjects.FirstOrDefault（x=>x.Users.FirstName.ToLower（）.Contains（word）||
x、 使用者
.LastName.ToLower（）.Contains（word））；
if（ParentObject！=nul