delegate, Func<T>, Predicate<T> , LinQ ifadeleri

Merhaba, LinQ teknolojisi c# 3.0 ile gelen bir teknolojidir. Bu teknoloji ile uzatılmış methodlar ile tanışmık olduk.  Func<T>, Predicate<T> gibi delegeler yine bizim linq ile gelmiştir. Ben yine sıfırdan başlayacağım. Func<T>, Func<T,TResult> gibi 15, 16 adet çeşidi bulunmaktadır.

http://msdn.microsoft.com/en-us/library/yxcx7skw.aspx bu linkden bu tipleri görebilrisiniz.

namespace delegateAnonimMethodlar
{
    delegate  int delegem(int sayi);
    class Program
    {
        static void Main(string[] args)
        {
            delegem islemyap = new delegem(kub);

           Console.WriteLine(islemyap.Invoke(5));
        }

        static int kub(int sayi)
        {
            return sayi * sayi * sayi;
        }
    }
}

Şimdide aynı kodu AnonysMethod kullanarak yapalım. (İsimsiz yöntemler). İsimsiz methodlar sadece bir iki defa kullanılacak yerlerde kullanılabilir.

namespace delegateAnonimMethodlar
{
    delegate  int delegem(int sayi);
    class Program
    {
        static void Main(string[] args)
        {
            delegem islemyap = delegate(int sayi)
                {
                    return sayi*sayi*sayi;
                };

           Console.WriteLine(islemyap.Invoke(5));
        }
    }
}

Şimdide lambada operatörü kullanarak yapalım..

namespace delegateAnonimMethodlar
{
    delegate  int delegem(int sayi);
    class Program
    {
        static void Main(string[] args)
        {
            delegem islemyap = (sayi)=>sayi*sayi*sayi;
           Console.WriteLine(islemyap.Invoke(5));
        }
    }
}

Şimdi bir sayı dizisinden FindAll methodunu kullanarak  dörde bölünensayıları çekelim.  

namespace delegateAnonimMethodlar
{
    class Program
    {
        static void Main(string[] args)
        {
            var sayilar = new List<int> { 2, 4, 5, 6, 98, 76, 45, 32, 45 };
            var bulunanlar=sayilar.FindAll(bul);
            
            foreach (var item in bulunanlar)
	        {
                Console.WriteLine(item);
	        }
        }
        static bool bul(int sayi)
        {
            return sayi % 4 == 0;
        }
    }
}

Şimdide lambada ifadesiyle aynı işlemi yapalım..

namespace delegateAnonimMethodlar
{
    class Program
    {
        static void Main(string[] args)
        {
            var sayilar = new List<int> { 2, 4, 5, 6, 98, 76, 45, 32, 45 };
            var bulunanlar=sayilar.FindAll(x=>x%4==0);
            
            foreach (var item in bulunanlar)
	        {
                Console.WriteLine(item);
	        }
        }
    }
}

Şimdide linq da kullanılan, where  genişletilmiş metodu ile  Func<> deyimini kullanarak sorgu yazalım.. Func deyiminin farkı birden fazla parametre geçirmemizdir.

static void Main(string[] args)
        {
            var sayilar = new List<int> { 2, 4, 5, 6, 98, 76, 45, 32, 45 };
            var bulunanlar = sayilar.Where(bul);
            
            foreach (var item in bulunanlar)
	        {
                Console.WriteLine(item);
	        }
        }
        static bool bul(int s)
        {
            return s > 10;
        }

Tabii bu ornekde bir parametre kullanıldığı için ve dönüş değeri bool olduğu için  Predicate<> deyiminden pek farkı olmayacak. Tabii örneği kısaltarak yamak çok oğrıu olacaktır.

static void Main(string[] args)
        {
            var sayilar = new List<int> { 2, 4, 5, 6, 98, 76, 45, 32, 45 };
            var bulunanlar = sayilar.Where(s=>s>10);
            
            foreach (var item in bulunanlar)
	        {
                Console.WriteLine(item);
	        }
        }

Bir Örnek daha yapalım..

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace delegateAnonimMethodlar
{
    class Program
    {
           public static void Main()
           {
              Random rnd = new Random();
              var sepet = new List<Urun>();
              sepet.AddRange( new Urun[] { new Urun(1,"elma",12), 
                                                 new Urun(2,"armut",20),
                                                 new Urun(3,"portakala",30),
                                                 new Urun(4,"ayva", 10),
                                                 new Urun(5,"muz",5) } );
              int[] fiyat = { 10, 20, 30, 40 };
              int bul = fiyat[rnd.Next(0, fiyat.Length)];
              Console.WriteLine("Rastgele üretilen fiyat {0}:", bul);
              foreach (var item in sepet.FindAll( x => x.Fiyat  <= bul))
                 Console.WriteLine("{0}: {1}", item.Name, item.Fiyat);
           }
    }
    class Urun
    {
        public Urun(int id, string ad, int fiyat)
        {
            Id=id;Name=ad;Fiyat=fiyat;
        }
        public int Id {get; set; }
        public string Name {get;set; }
        public int Fiyat { get ; set; }
    }
 }

Şimdide msdn.com dan bir örnek ile açıklayalım. Burada point bir struct dır.

using System;
using System.Drawing;

public class Example
{
   public static void Main()
   {
      // Create an array of Point structures.
      Point[] points = { new Point(100, 200), 
                         new Point(150, 250), new Point(250, 375), 
                         new Point(275, 395), new Point(295, 450) };

      // Find the first Point structure for which X times Y   
      // is greater than 100000. 
      Point first = Array.Find(points, x => x.X * x.Y > 100000 );

      // Display the first structure found.
      Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
   }
}
// The example displays the following output: 
//        Found: X = 275, Y = 395

Bir sonraki yazımda görüşmek üzeri hoşçakalın.