C# Lambda ignore case

Question

I want to ignore case using this LAMBDA query:

public IEnumerable<StationDto> StationSearch(string search)
        {
            var data = GenerateDtos();

            var list = data.Where(x => x.StationName.Contains(search));




            //var searchDto = new SearchDto {



            return null;
        }



        private static IEnumerable<StationDto> GenerateDtos()
        {
            return new List<StationDto>()
            {
                new StationDto()
                {
                    StationId = 1,
                    StationName = "DARTFORD"
                },
                new StationDto()
                {
                    StationId = 2,
                    StationName = "DARTMOUTH"
                },
                new StationDto()
                {
                    StationId = 3,
                    StationName = "TOWER HILL"
                },
                new StationDto()
                {
                    StationId = 4,
                    StationName = "DERBY"
                },
                new StationDto()
                {
                    StationId = 5,
                    StationName = "lIVERPOOL"
                },
                new StationDto()
                {
                    StationId = 6,
                    StationName = "LIVERPOOL LIME STREET"
                },
                new StationDto()
                {
                    StationId = 7,
                    StationName = "PADDINGTON"
                },
                new StationDto()
                {
                    StationId = 8,
                    StationName = "EUSTON"
                },
                new StationDto()
                {
                    StationId = 9,
                    StationName = "VICTORIA"
                },
            };
        }
    }

If I search for "DAR" it will bring back two but "dar" brings back 0 items. How would I modify this query?

It appears all the names are capitalized. Why should you need to use `dar` instead of `DAR`? — Rogue, Jun 26 '15 at 15:56
@RogueCSDev it's mostly for robustness. I know that I can use to upper or to lower to get around it but I was wondering if there is a better way. — nick gowdy, Jun 26 '15 at 16:01
What if one of the stations is named `"FOODAR"`? Would you expect your `"DAR"` (or `"dar"`) search to find that one? — kdbanman, Jun 26 '15 at 17:13
@kdbanman Well the string dar is contained within foodar so I would expect it. — nick gowdy, Jun 26 '15 at 19:50
Thanks. Just making sure your requirements don't have surprises. — kdbanman, Jun 26 '15 at 19:52

Claudio Redi · Accepted Answer · 2015-06-26T17:26:40.133

5

Assuming you're talking about x.StationName.Contains(search) you could do

var list = data
  .Where(x => x.StationName.IndexOf(search, StringComparison.OrdinalIgnoreCase) >= 0)

You could also add a String extension method

public static class StringExtensions
{
    public static bool Contains(this string thisObj, string value, StringComparer compareType) 
    {
        return thisObj.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
    }
}

and use it like this

 var list = data
   .Where(x => x.StationName.Contains(search, StringComparison.OrdinalIgnoreCase));

edited Jun 26 '15 at 17:26

answered Jun 26 '15 at 15:54

Claudio Redi

67,454
15
130
155

this brings me back everything. – nick gowdy Jun 26 '15 at 16:03
@nickgowdy: then it means everything match with search criteria :) – Claudio Redi Jun 26 '15 at 16:33
While this is more performant than `ToLower()` or `ToUpper()` case conversions, I think it is less readable. – kdbanman Jun 26 '15 at 17:08
@kdbanman: I agree about readability but `toLower()` seems too verbose too. I added an alternative using an extension method. – Claudio Redi Jun 26 '15 at 18:01
Oooh. Nifty. I didn't know C# supported patching primitives. – kdbanman Jun 26 '15 at 18:43
@ClaudioRedi Thank's Claudio, this is what I needed. – nick gowdy Jun 26 '15 at 20:13

score 4 · Answer 2 · answered Jun 26 '15 at 15:54

4

Something like this would work:

var list = data.Where(x => x.StationName.ToLower().Contains(search.ToLower()));

Or

var list = data.Where(x => x.StationName.Contains(search, StringComparer.OrdinalIgnoreCase);

Not sure the syntax is correct on the second. I think it is.

answered Jun 26 '15 at 15:54

Randy Minder

47,200
49
204
358

Both of these (especially the first one) are *far* more readable than `IndexOf(...) >= 0`. Good answer. – kdbanman Jun 26 '15 at 17:05

score 1 · Answer 3 · answered Jun 26 '15 at 15:56

1

Use something like below:

var list = data.Where(x => x.StationName.ToUpper().Contains(search.ToUpper()));

answered Jun 26 '15 at 15:56

ATP

553
1
3
16

score 1 · Answer 4 · edited May 23 '17 at 11:54

You could utilize Fody which is a IL Weaving tool created for .net and use the Caseless addon.

When utilizing this library you can write code like this (as per the documentation):

public bool Foo()
{
    var x = "a";
    var y = "A";
    return x == y;
}

but would be compiled as:

public bool Foo()
{
    var x = "a";
    var y = "A";
    return string.Equals(x, y, StringComparison.OrdinalIgnoreCase);
}

So that you don't have to remember to either set ignorecase or ToUpper/ToLower. I don't know about you, but I can't think of a time when I actually wanted case sensitive compares of strings... this could be applied to the entire project so you never have to remember to do it again! :)

In your specific example, the existing code you're using of:

var list = data.Where(x => x.StationName.Contains(search));

would bring back all instances of "DAR" indiscriminate of case.

score 0 · Answer 5 · answered Oct 06 '22 at 15:19

This worked the best for me. I was needing to do contains on a List.

Extension Method:

public static bool In(this List<string> thisObj, string value)
{
    foreach (var v in thisObj)
    {
        if (v.Equals(value, StringComparison.OrdinalIgnoreCase))
            return true;
    };
    return false;
}

Usage:

public bool IsFound(string value){
    return someStringList.In(value);
}

I went with "In" to distinguish from the Contains method.

C# Lambda ignore case

5 Answers5