(1) Here, I utilize the List.Contains() method to eliminate the inner nested Find():

private void validateUserInput(List listWithValuesEnteredByUser)
{
List asiaList = MethodThatReturnsAllCountriesInAsia();

if (string.IsNullOrEmpty(
listWithValuesEnteredByUser.Find(current => !asiaList.Contains(current)))) {
// country not found, user input found to be invalid
}
}

NOW, LET’S GO FOR SOME ONE-LINERS!!!

(2) We can simply return all INVALID input strings (by changing the return type of the function):

private List validateUserInput(List listWithValuesEnteredByUser)
{
return listWithValuesEnteredByUser.FindAll(current =>
!MethodThatReturnsAllCountriesInAsia().Contains(current));
}

(3) Or, return true if all user input is valid (return type changed to bool):

private bool validateUserInput(List listWithValuesEnteredByUser)
{
return listWithValuesEnteredByUser.FindAll(current =>
!MethodThatReturnsAllCountriesInAsia().Contains(current)).Count == 0;
}

Well, I learned a lot! Thanks for the article that gave me something to play with!

Kevin
San Luis Obispo CA

(1) The outer foreach loop presents an opportunity to use the List.ForEach() method that is IDENTICAL in use to the List.Find() method. Thus, your solution now has NESTED anonymous delegates and becomes:

listWithValuesEnteredByUser.ForEach(delegate(string current) {
if (string.IsNullOrEmpty(asiaList.Find(delegate(string input) {
return input == current;
}
))) {
// country not found, user input found to be invalid
}
});

(2) Anonymous delegate functions are good–lambda expressions/statements can be better! I’ll leave it for you to read up on lambda expressions, however, suffice it to say, an anonymous delegate function in the form of “delegate(string val) { return val == x; }” is IDENTICAL TO the lambda expression “val => val == x”. With lambda expressions you don’t have to re-state the redundant information (‘delegate’, ’string’, ‘return’). Your ‘if’ function now becomes simply:

if (string.IsNullOrEmpty(asiaList.Find(input => input == current))) { }

This code is IDENTICAL to yours.

(3) In addition to functions, lambda notation can also be used define a statement block (C# only as of VS2008). Thus, in my section (1) above, you can likewise get rid of the first anonymous delegate function.

Hence, the IDENTICAL CODE to yours, re-written using ForEach() and lambda notation is now:

listWithValuesEnteredByUser.ForEach(current => {
if (string.IsNullOrEmpty(asiaList.Find(input => input == current))) {
// country not found, user input found to be invalid
}
});

Using lambda notation, think of the variable name on the left side of the => as the parameter of your delegate function (because it actually is just notation for the exact same thing):

“parameter =>” replaces “delegate(type parameter)”

You don’t have to specify “delegate” or the type (string, in your case) because it is already inferred from the type of the List collection. This reduces typing!

On the right side of the => notation, you can specify a simple expression whose value is returned or a statement block…. depending on what is called for:

(1) The List.Find() method expects a “Predicate”. Webster’s dictionary says a predicate (n.) is “a propositional function of one or more arguments. The predicate you are using is “return input == current;”. Thus, the propositional function (predicate) is “is ‘input’ equal to ‘current’?”. The bool result is the return value. Think of “Predicate” as a filter. Your predicate function defines and filters what Find() is looking for.

(2) The List.ForEach() method expects an “Action” delegate (defined in the System namespace). The Action(T) delegate “Encapsulates a method that takes a single parameter and does not return a value.” Thus, notice my use of a statement block “{…}” to the right side of the => lambda notation. This entire statement block is executed “ForEach” value in the collection, with “current” as the parameter of the function.

A simplification that may help you understand the List.ForEach() method and “Action” delegate is this line of code which writes all user entered values to the console:

listWithValuesEnteredByUser.ForEach(value => Console.WriteLine(value));

CONCLUSION:
Don’t forget what you know about delegates and anonymous delegate functions! Lambda notation is not something different! It’s just an easier way to write the exact same thing.