LINQ query to select based on property

IEnumerable<MyClass> objects = ...
foreach(MyClass obj in objects)
{
  if(obj.someProperty != null)
    SomeFunction(obj.someProperty);
}

I get the feeling I can write a smug LINQ version using a lambda but all my C# experience is 'classical' i.e more Java-like and all t开发者_如何学运维his Linq stuff confuses me.

What would it look like, and is it worth doing, or is this kind of Linq usage just seen as showing off "look I know Linq!"

LINQ itself doesn't contain anything for this - I'd would use a normal foreach loop:

foreach (var value in objects.Select(x => x.someProperty)
                             .Where(y => y != null))
{
    SomeFunction(value);
}

Or if you want a query expression version:

var query = from obj in objects
            let value = obj.SomeProperty
            where value != null
            select value;
foreach (var value in query)
{
    SomeFunction(value);
}

(I prefer the first version, personally.)

Note that I've performed the selection before the filtering to avoid calling the property twice unnecessarily. It's not for performance reasons so much as I didn't like the redundancy :)

While you can use ToList() and call ForEach() on that, I prefer to use a straight foreach loop, as per Eric's explanation. Basically SomeFunction must incur a side-effect to be useful, and LINQ is designed with side-effect-free functions in mind.

objects.where(i => i.someProperty != null)
    .ToList()
    .ForEach(i=> SomeFunction(i.someProperty))

Although it can be done with Linq, sometimes its not always necessary. Sometimes you lose readability of your code. For your particular example, I'd leave it alone.

One option is to use the pattern outlined in the book Linq In Action which uses an extension method to add a ForEach operator to IEnumerable<>

From the book:

public static void ForEach<T> (this IEnumerable<T> source, Action<T> func)
{
   foreach (var item in source)
      func(item)
}

Then you can use that like this:

(from foo in fooList 
  where foo.Name.Contains("bar")
  select foo)
  .ForEach(foo => Console.WriteLine(foo.Name));

LINQ is used to create a result, so if you use it to call SomeFunction for each found item, you would be using a side effect of the code to do the main work. Things like that makes the code harder to maintain.

You can use it to filter out the non-null values, though:

foreach(MyClass obj in objects.Where(o => o.someProperty != null)) {
  SomeFunction(obj.someProperty);
}

You can move the if statement into a Where clause of Linq:

IEnumerable<MyClass> objects = ...
foreach(MyClass obj in objects.Where(obj => obj.someProperty != null)
{
    SomeFunction(obj.someProperty);
}

Going further, you can use List's ForEach method:

IEnumerable<MyClass> objects = ...
objects.Where(obj => obj.someProperty != null).ToList()
    .ForEach(obj => SomeFunction(obj.someProperty));

That's making the code slightly harder to read, though. Usually I stick with the typical foreach statement versus List's ForEach, but it's entirely up to you.