[Evolution in aciton] C#1.1=>2.0=>3.0 [Querying Collections]

If want filter out a price greater than $10 ,in the products. we need to loop around,testing each element and printing it out where appropriate.

 

Looping ,testing,printing out
C#1.1

static void Main()
        {
            ArrayList products = Product.GetSampleProducts();
            foreach (Product product in products)
            {
                if (product.Price > 10m)
                {
                    Console.WriteLine(product);
                }
            }
        } 

The dependency is obvious because of the nesting.

C#2.0 Lets us flatten things out a bit

 static void Main()
        {
            //Get Products and Save to List<T>
            List<Product> products = Product.GetSampleProducts();
            //Define filter 
            Predicate<Product> filterPrice = delegate(Product product)
            {
                return product.Price > 10m;
            };
            //FindAll this in List<Product>
            List<Product> matchPrice = products.FindAll(filterPrice); 

            //Define print out
           Action<Product> printPrices = delegate(Product product)
            {
                Console.WriteLine(product);
            }; 

            matchPrice.ForEach(printPrices);
        } 

 

In particular, it makes it very easy to change the condition we're testing for and the aciton we take on each of the matchs independently.

* The FindAll and ForEach methods in C#2.0 just help to encourage you to consider separation of concerns.

So, we could have put all the testing and printing into one statment.[C#2.0]

static void Main()
       {
           List<Product> products = Product.GetSampleProducts();
           products.FindAll(delegate(Product p) 

                                        { return p.Price > 10; })
                         .ForEach(delegate(Product p) 

                                       { Console.WriteLine(p); }

                                      );
       }

That's a bit better, But it is getting in the way Developer , and adding noise to the code, which hurts readability. I still prefer the C#1.1 version.

C#3.0
            improves matters dramatically by removing a lot of the fluff surrounding the actual logic of the delegate.

 static void Main()
        {
            List<Product> products = Product.GetSampleProducts();
            foreach (Product product in products.Where(p => p.Price > 10))
            {
                Console.WriteLine(product);
            }
        }

So much For this!