[ray1234]

// racers is  list<racer>  type

racers.ForEach(Console.Writeline);

from this code, how is console.writeline excepted as a parameter for the ForEach Method when the parameter type is Action<t> ?

also why was console.writeline in the above statement excepted without parenthesis? what does console.writeline mean without parenthesis?

thanks

ray

[darek9576]

Are you trying to print each racer?

[sepp2k]

Action<T> is a delegate type. It represents void methods that take one argument of type T (or a supertype thereof). Console.WriteLine is a void method that takes an argument of type Object. Since Object is a supertype of Racer (and T in this case is Racer since, as you said, racers is a List<Racer>), Console.WriteLine can be used as an argument to ForEach.

Quote

also why was console.writeline in the above statement excepted without parenthesis?

Because we're passing the method WriteLine as an argument to ForEach - not the result of calling the method.

[tlhIn`toq]

.

This post has been edited by tlhIn`toq: 07 September 2012 - 01:32 PM
Reason for edit:: Comment withdrawn

[sepp2k]

tlhIn`toq, on 07 September 2012 - 10:14 PM, said:

That line of code is pretty much gibberish.

No, it's not.

Quote

foreach creates a loop.

Yes, that's true (though entirely irrelevant). However List<T>.ForEach is a method of the List<T> class, which takes an Action<T> as its argument.

Quote

And you can't send a command such as Console.WriteLine as a parameter.

Of course you can pass methods as arguments. That's why delegate types exist.

[Skydiver]

The List<T>.ForEach() above is from the LINQ extension methods. It is different from foreach keyword.

Yes, you can just give it a function name. For example:

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication1
{
    class Dallasite
    {
        public string Name { get; set; }

        public override string ToString()
        {
            return Name;
        }
    }

    class Program
    {
        static void DoDebbie(Dallasite dallasite)
        {
            Console.WriteLine("Debbie does {0}.", dallasite.Name);
        }

        static void Main(string[] args)
        {
            List<Dallasite> dallasites = new List<Dallasite>();
            dallasites.Add(new Dallasite() { Name = "Rick" });
            dallasites.Add(new Dallasite() { Name = "Mr. Greenfield" });
            dallasites.Add(new Dallasite() { Name = "Mr. Hardwick" });

            Console.WriteLine("Dallasites:");
            dallasites.ForEach(Console.WriteLine);

            Console.WriteLine("Debbie does Dallas:");
            dallasites.ForEach(DoDebbie);
        }
    }
}

[sepp2k]

Skydiver, on 07 September 2012 - 10:31 PM, said:

The List<T>.ForEach() above is from the LINQ extension methods. It is different from foreach keyword.

Actually it's defined directly on the List<T> class (and only on the List<T> class - it's not defined for other Enumerables) - not as an extension method. (Yes, I'm in smart ass mode today.)

This post has been edited by sepp2k: 07 September 2012 - 01:35 PM

[Skydiver]

LOL! We need more smartasses. It keeps everyone on their toes. I usually play the smartass Saturday to Tuesday.

[ray1234]

sepp2k, on 07 September 2012 - 01:14 PM, said:

Action<T> is a delegate type. It represents void methods that take one argument of type T (or a supertype thereof). Console.WriteLine is a void method that takes an argument of type Object. Since Object is a supertype of Racer (and T in this case is Racer since, as you said, racers is a List<Racer>), Console.WriteLine can be used as an argument to ForEach.

Quote

also why was console.writeline in the above statement excepted without parenthesis?

Because we're passing the method WriteLine as an argument to ForEach - not the result of calling the method.

thanks, query solved

[Curtis Rutland]

I've wondered why the ForEach method was only defined on List. I don't know any good reason it's not defined for IEnumerables. It's a pretty easy extension method to add though.

class Program
{
    static void Main(string[] args)
    {
        Enumerable.Range(1, 10).ForEach(Console.WriteLine);
        Console.ReadKey();
    }
}

public static class Extensions
{
    public static void ForEach<T>(this IEnumerable<T> collection, Action<T> predicate)
    {
        foreach (var i in collection)
        {
            predicate(i);
        }
    }
}

[Momerath]

In line 14 of your code why did you use 'var' rather than 'T'?

[Curtis Rutland]

Force of habit. The style that I and my coworkers follow is to use var whenever possible. Traditionalists don't like it, and I didn't like var either when I first started using 3.5. But to be honest, I've found using it like that to be really convenient, and we've really never had an issue with readability.