Select the Enum to classify a string based on the first word found

Question

I have written a small function that will check a string to see if it contains a certain word.

Depending on the word that is found first, the function will return the correct Enum value that needs to be used further down the line of the program.

Would there be a better way to check a string to see if it contains a certain Enum value?
The thing that gives me a little alarm bell in my head is that i am checking the same string 5 times in this function.

Enum

 public enum QuestionIdentifier
{
 Wie,
 Wat,
 Waarom,
 Wanneer,
 Hoe,
 Andere
}

Function

private QuestionIdentifier IdentifyQuestion(string vQuestion)
 {
 //QuestionToLower
 string vQTL = vQuestion.ToLower();
 if (vQTL.Contains("wie"))
 {
 return QuestionIdentifier.Wie;
 }else if (vQTL.Contains("wat"))
 {
 return QuestionIdentifier.Wat;
 }else if (vQTL.Contains("waarom"))
 {
 return QuestionIdentifier.Waarom;
 }else if (vQTL.Contains("wanneer"))
 {
 return QuestionIdentifier.Wanneer;
 }else if (vQTL.Contains("hoe"))
 {
 return QuestionIdentifier.Hoe;
 }else
 {
 return QuestionIdentifier.Andere;
 }
 }

Answer 1

You can utilise the Enum class which can shorten your code significantly and it will be easier for future updates

private static QuestionIdentifier IdentifyQuestion(string vQuestion)
{
 //QuestionToLower
 string vQTL = vQuestion.ToLower();
 string[] enumNames = Enum.GetNames(typeof(QuestionIdentifier));
 foreach (var enumName in enumNames)
 {
 if (vQTL.Contains(enumName.ToLower()))
 {
 return (QuestionIdentifier) Enum.Parse(typeof(QuestionIdentifier), enumName);
 }
 }
 return QuestionIdentifier.Andere;
}

or with LINQ

private static QuestionIdentifier IdentifyQuestion(string vQuestion)
{
 string vQTL = vQuestion.ToLower();
 string[] enumNames = Enum.GetNames(typeof(QuestionIdentifier));
 string enumValueName = enumNames.FirstOrDefault(x => vQTL.Contains(x.ToLower()));
 return enumValueName != null
 ? (QuestionIdentifier) Enum.Parse(typeof(QuestionIdentifier), enumValueName)
 : QuestionIdentifier.Andere;
}

Now you can add as much types as you want in your enum without even touching this method it will still work and find your newly created type.

Update

As @t3chb0t pointed in the comments there is a way to avoid calling .ToLower() on both the input string and the enum value by using the .IndexOf() overload which accepts different comparison types :

private static QuestionIdentifier IdentifyQuestion(string vQuestion)
{
 string[] enumNames = Enum.GetNames(typeof(QuestionIdentifier));
 string enumValueName =
 enumNames.FirstOrDefault(x => vQuestion.IndexOf(x, StringComparison.OrdinalIgnoreCase) >= 0);
 return enumValueName != null
 ? (QuestionIdentifier)Enum.Parse(typeof(QuestionIdentifier), enumValueName)
 : QuestionIdentifier.Andere;
}

• t3chb0t: Enum.Parse has an overload for case handling where you can specifyignoreCase: true - no need to ToLower so does the Contains method support a similar parameter, a StringComparison.OrdinalIgnoreCase ;-)
• Denis: Does that looks better @t3chb0t ?
• t3chb0t: It's an improvement but... it still can crash on Enum.Parse because if the case of the value does not match the enum name Parse won't accept it without ignoreCase: true. I think the best alternative is to use Enum.TryParse<T>here.
• Denis: enumValueName is always the same as the value in the enum. It's taken directly from the enum names, TryParse is redundant here
• t3chb0t: oh, crap, you're right

Answer 2

If someone likes LINQ you can do it with one long chain of extensions and a coalesce ?? operator at the end:

return 
 Enum
 .GetValues(typeof(QuestionIdentifier))
 // The array is type-less so you need to cast each value first
 .Cast<QuestionIdentifier>()
 // Check if the string contains the value and get it or null
 .Select(x => vQuestion.Contains(x.ToString(), StringComparison.OrdinalIgnoreCase) ? x : (QuestionIdentifier?)null)
 // Get first non-null value
 .FirstOrDefault(x => x.HasValue)
 // Nothing found so use the default
 ?? QuestionIdentifier.Andere;

---

The default Contains does not accept a string but only char so let's create an extension that does:

public static bool Contains(this string str, string value, StringComparison stringComparison)
{
 return 
 !string.IsNullOrEmpty(str) &&
 !string.IsNullOrEmpty(value) &&
 str.IndexOf(value, stringComparison) >= 0;
}

• t3chb0t: @denis of course, fixed, thx
• t3chb0t: @denis Contains should accept a string... well, it's a case for a new extension, using the IndexOf is too much work for such a simple task like this.
• Denis: Haha that's something useful to add indeed.
• pinkfloydx33: Your Contains method isn't making use of the third parameter
• t3chb0t: @pinkfloydx33 thx, fixed, I've fixed it once already and later replaced it with the invalid version when edited again lol

Answer 3

You can iterate the enum

public static QuestionIdentifier QuestionIdentifierContains(string question)
{
 foreach (QuestionIdentifier questionIdentifier in Enum.GetValues(typeof(QuestionIdentifier)))
 {
 if (question.IndexOf(questionIdentifier.ToString(), StringComparison.CurrentCultureIgnoreCase) >= 0)
 return questionIdentifier;
 }
 return QuestionIdentifier.Andere;
}

As already pointed out String.Contains does not support ignore case but IndexOf of does support ignore case.

Not as pretty but can use ToUpper (or ToLower)

public static QuestionIdentifier QuestionIdentifierContainsUpper(string question)
{
 string questionUpper = question.ToUpper();
 foreach (QuestionIdentifier questionIdentifier in Enum.GetValues(typeof(QuestionIdentifier)))
 {
 if (questionUpper.Contains(questionIdentifier.ToString().ToUpper()))
 return questionIdentifier;
 }
 return QuestionIdentifier.Andere;
}

• paparazzo: I tested and the first answer from dennis is faster