How can I make the line below case insensitive?
drUser["Enrolled"] =
(enrolledUsers.FindIndex(x => x.Username == (string)drUser["Username"]) != -1);
I was given some advice earlier today that suggested I use:
x.Username.Equals((string)drUser["Username"], StringComparison.OrdinalIgnoreCase)));
the trouble is I can't get this to work, I've tried the line below, this compiles but returns the wrong results, it returns enrolled users as unenrolled and unenrolled users as enrolled.
drUser["Enrolled"] =
(enrolledUsers.FindIndex(x => x.Username.Equals((string)drUser["Username"],
StringComparison.OrdinalIgnoreCase)));
Can anyone point out the problem?
drUser["Enrolled"]
be? It looks like a boolean value, but FindIndex()
returns the index. If the index of that user is 0, then it will return 0, which may be false. When, in reality is is true. The Exists()
method may be better in this case.
This is not the best practice in .NET framework (4 & +) to check equality
String.Compare(x.Username, (string)drUser["Username"],
StringComparison.OrdinalIgnoreCase) == 0
Use the following instead
String.Equals(x.Username, (string)drUser["Username"],
StringComparison.OrdinalIgnoreCase)
Use an overload of the String.Equals method to test whether two strings are equal. Use the String.Compare and String.CompareTo methods to sort strings, not to check for equality.
You should use static String.Compare
function like following
x => String.Compare (x.Username, (string)drUser["Username"],
StringComparison.OrdinalIgnoreCase) == 0
String.Equals
instead of String.Compare
. There's no need to compute which one is greater, just that they are not equal.
IEquatable
and IComparable
do NOT do the same thing, and you can have classes that implement one but in which it would make NO sense to implement the other. For example, you could order sensor samplings by time without any of them being equal (IComparable). And, you can indicate whether things are equal (IEquatable) but it makes no sense to order them (say, computer serial numbers).
Please use this for comparison:
string.Equals(a, b, StringComparison.CurrentCultureIgnoreCase);
Others answer are totally valid here, but somehow it takes some time to type StringComparison.OrdinalIgnoreCase
and also using String.Compare
.
I've coded simple String extension method, where you could specify if comparison is case sensitive or case senseless with boolean, attaching whole code snippet here:
using System;
/// <summary>
/// String helpers.
/// </summary>
public static class StringExtensions
{
/// <summary>
/// Compares two strings, set ignoreCase to true to ignore case comparison ('A' == 'a')
/// </summary>
public static bool CompareTo(this string strA, string strB, bool ignoreCase)
{
return String.Compare(strA, strB, ignoreCase) == 0;
}
}
After that whole comparison shortens by 10 characters approximately - compare:
Before using String extension:
String.Compare(testFilename, testToStart,true) != 0
After using String extension:
testFilename.CompareTo(testToStart, true)
You can (although controverse) extend System.String
to provide a case insensitive comparison extension method:
public static bool CIEquals(this String a, String b) {
return a.Equals(b, StringComparison.CurrentCultureIgnoreCase);
}
and use as such:
x.Username.CIEquals((string)drUser["Username"]);
C# allows you to create extension methods that can serve as syntax suggar in your project, quite useful I'd say.
It's not the answer and I know this question is old and solved, I just wanted to add these bits.
I'd like to write an extension method for EqualsIgnoreCase
public static class StringExtensions
{
public static bool? EqualsIgnoreCase(this string strA, string strB)
{
return strA?.Equals(strB, StringComparison.CurrentCultureIgnoreCase);
}
}
I think you will find more information in this link:
http://codeidol.com/community/dotnet/controlling-case-sensitivity-when-comparing-two-st/8873/
Use the Compare static method on the String class to compare the two strings. Whether the comparison is case-insensitive is determined by the third parameter of one of its overloads. For example:
string lowerCase = "abc";
string upperCase = "AbC";
int caseInsensitiveResult = string.Compare(lowerCase, upperCase,
StringComparison.CurrentCultureIgnoreCase);
int caseSensitiveResult = string.Compare(lowerCase,
StringComparison.CurrentCulture);
The caseSensitiveResult value is -1 (indicating that lowerCase is "less than" upperCase) and the caseInsensitiveResult is zero (indicating that lowerCase "equals" upperCase).
How about using StringComparison.CurrentCultureIgnoreCase
instead?
you can always use functions: .ToLower(); .ToUpper();
convert your strings and then compare them...
Good Luck
str == "a"
or case "a"
, or a hashtable check. For the question at hand, though... yeah, best to do it the Right Way.
Success story sharing
string.Compare
, notString.Compare
.string
is better practice thanString
since it is a language keyword. For one,String
could be something other thanSystem.String
, whereasstring
cannot be. Also,string
is more or less guaranteed to exist in C#, whereasString
is technically part of .NET rather than C#.