using System;

using System.Collections.Generic;

using System.Linq;

​

public class Dog

{

    public string Name {get;set;}

    public string Breed {get;set;}

    public int Age {get;set;}

    public string Owner {get;set;}

}

​

​

public class Program

{

    public static void Main()

    {

        //Let's make some dogs

        var spike = new Dog() {Name="Spike",Breed="Jack Russell", Age=5, Owner="Ben"};

        var tinka = new Dog() {Name="Tinka",Breed="Eskie", Age=5,Owner="John"};

        var petey = new Dog() {Name="Petey",Breed="Eskie", Age=8,Owner="John"};

        var mocha = new Dog() {Name="Mocha",Breed="Pom", Age=9,Owner="Jessica"};

        //Now we'll make a dog collection

        var kennel = new List<Dog>();

        kennel.Add(spike);

        kennel.Add(tinka);

        kennel.Add(petey);

        kennel.Add(mocha);

        //Now we can play with linq

        //Linq is just a bunch of extension methods written by ms to do common things with collections.

        //Lets make our own extension method just to refresh

        "ForEach:".P();

        kennel.ForEach(dog => Console.WriteLine(dog.Name));

        //Neat

        //so let's look at some common linq methods

        //Count. Pretty obvious.

        "\nCount:".P();

        kennel.Count().P();

        //Contains. Returns a bool

        "\nContains:".P();

        var snowball =new Dog() {Name="Snowball",Breed="Westie", Age=15, Owner="Bill"};

        kennel.Contains(snowball).P();

        kennel.Contains(tinka).P();

        //Where. Takes a lamba that takes a type of the members of the collection. The lamba returns a bool and the Where method returns members of the collection that match that.

        "\nWhere:".P();

        kennel.Where(dog => dog.Breed.Equals("Eskie")).ForEach(dog => dog.Name.P());

        kennel.Where(dog => dog.Age > 7).ForEach(dog => dog.P());

        //Select. Lets us select elements of a memeber

        "\nSelect:".P();

        kennel.Select(dog => dog.Breed).ForEach(dog => dog.P()); //In this case select returns an IEnumerable<string>

        kennel.Select(dog => new {OwnerName = dog.Owner, DogName = dog.Name}).ForEach(newType => newType.P()); //we can also return new anonymous types

        //Single. Returns a single value that matches a bool expression. Throw an exception if more than one exists

        "\nSingle:".P();

        kennel.Single(dog => dog.Breed.Equals("Jack Russell")).Name.P();

        try

        {

            kennel.Single(dog => dog.Breed.Equals("Eskie"));

        }

        catch(Exception ex)

        {

            ex.Message.P();

        }

        //On that note we also have SingleOrDefault. If there is no match it returns a default object

        "\nSingleOrDefault".P();

        (kennel.SingleOrDefault(dog => dog.Breed.Equals("Whippet"))==null).P(); //a default object is null

        //Distinct. Omits duplicate values

        "\nDistinct:".P();

        kennel.Select(dog => dog.Breed).Distinct().ForEach(dogBreed => dogBreed.P());

        //First and Last

        "\nFirstAndLast:".P();

        kennel.First().Name.P();

        kennel.Last().Name.P();

        //OrderBy

        "\nOrderBy:".P();

        kennel.OrderBy(dog => dog.Name).Select(dog => dog.Name).ForEach(dogName => dogName.P());

        //Average

        "\nAverage:".P();

        kennel.Average(dog => dog.Age).P();

        //Sum

        "\nSum:".P();

        kennel.Sum(dog => dog.Age).P();

        //A slightly confusing one is aggregate. It takes a lamda that takes the current and next member in the collection and does things with them. I use it to build strings

        "\nAggregate:".P();

        kennel.Select(dog => dog.Name).Aggregate((currentDogName,nextDogName) => string.Format("{0}, {1}",currentDogName,nextDogName)).P();

        //As you've seen you can chain linq methods to do exactly what you want

    }

}

​

//extension methods have to live in a static class

public static class Extensions

{

    //The this keyword is used in an extension method.

    //By using the generic the extention method will work on any collection

    //We take in an action to be performed on every item in the collection

    public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)

    {

        foreach(var item in collection)

        {

            action(item);

        }

    }

    //for the sake of readability I'm going to make an exention method to replace Console.WriteLine

    public static void P(this object obj)

    {

        Console.WriteLine(obj.ToString());

    }

}