Delegate 4 :Generic Delegate Types

using System;

namespace Delegates3
{
    public delegate T Donusturucu<T>(T args);
    public class Islemler
    {
        public static void Donusum<T>(T[] degerler, Donusturucu<T> d)
        {
            for (int i = 0; i < degerler.Length; i++)
            {
                degerler[i] = d(degerler[i]);
            }
        }
    }
    class Program
    {
        static int Kare(int x) { return x * x; }
        static void Main(string[] args)
        {
            int[] degerler = { 1, 2, 3 };
            Islemler.Donusum<int>(degerler, Kare);
            foreach (int i in degerler)
            {
                Console.WriteLine(i);
            }
            Console.ReadKey();
        }
    }
}

Generic 3 : Metodlar ve Birden Fazla Parametre Kullanımı

using System;

namespace GenericOrnekleri
{
    class Program
    {
        //Genericleri metodlarda kullanmak.
        //Swap Metodu ile iki aynı türden değişkenin değerlerini birbirileriyle değiştirelim.
        static void Swap<T>(ref T a, ref T b)
        {
            T temp = a;
            a = b;
            b = temp;
        }


        public class A<T>
        {
            T value0;
        }

        /*
         Generics iki ya da daha fazla kullanılarak tanımlanabilir.
         * Bunun için<,> koymamız yeterlidir.
         */
        public class A<T1, T2>
        {
            public T1 value1;
            public T2 value2;
        }

        static void Main(string[] args)
        {
            int x = 5;
            int y = 10;
            Swap(ref x, ref y);

            Console.WriteLine("x = " + x);
            Console.WriteLine("y = " + y);



            A<int, string> a = new A<int, string>();
            a.value1 = 10;
            a.value2 = "On";
           
            Console.ReadKey();
        }
    }
}

Generics 2 : Neden Generic Kullanmalıyız.

namespace WhyGenericsExist
{
    class Program
    {
        /*Genericler Neden Var
        
         * Genericler bir kodu farklı tiplerde tekrar kullanabilmek için vardır.
         * Varsayalım integer yığınına ihtiyacımız olsun. Fakat generic kullanmayalım.
         * Bunun için ilk yol classımızı her gereken tip için teker teker oluşturmamızdır(IntStack,StringStack,...)
         * İkinci yolda nesnemizi Object olarak tanımlayıp kodda sürekli obj=>int e çevirmemiz gerekecektir.
         * İkinci yolumuzu bir örnekle gösterelim.
         */

        public class ObjectStack
        {
            int position;
            object[] data = new object[10];
            public void Push(object obj) { data[position++] = obj; }
            public object Pop()
            {
                return data[--position];
            }
        }
        static void Main(string[] args)
        {
            ObjectStack stack = new ObjectStack();
            stack.Push("s");//Integer Kullanmak istiyoruz fakat hata vermedi. Type Safety açısından zayıf.
            int i = (int)stack.Pop();//Çalışırken hata verecek. Çünkü s integerea dönüştürülemez.
        }
   

Generics 1 : Nedir?

using System;

namespace Generics
{
    class Program
    {
        /*
         * Generics
         C# bir farklı tipleri tekrar yazabilmek için iki ayrı mekanizmaya sahiptir. Bunlardan birisi inheritance diğeri generics.
         * Burada inheritance kullanırken onu taban olarak tanımlarız, oysa generics tanımlanırken vekil bir temadan faydalanırız.
         * Generic inheritance a göre daha yüksek tip güvenliğine sahiptir.
         *
         * Şimdi aşağıdaki generic tipini inceleyelim. Generic kullanırken <"Tip"> yazılır.
         * Aşağıdaki örnekte Stack<T> içerisine T="type" tipini tanımladık.
         * Burada T ye open type(açık tip) deriz. Açık tipler program çalışır haldeyken hata verir. Onları closed type(kapalı tip) formatına dönüştürmeliyiz.
         * Açık tip her formata dönüşebilir demektir. Fakat kapalı tipler standarttır.
         * Aşağıdaki örneği inceleyelim.
         */
        public class Stack<T>//Burada açık tip oluşturduk;
        {
            int position;
            T[] data = new T[100];
            public void Push(T obj) { data[position++] = obj; }
            public T Pop() { return data[--position]; }

            public Stack<T> Clone()
            {
                Stack<T> clone = new Stack<T>();//Bir classın içerisinde Stack<T> formatını kullanabiliriz. Çünkü burada program çalışır durumda değil.
                //Ve üretilirken klonlanan class kapalı tip olacaktır.
                return clone;
            }
        }





        static void Main(string[] args)
        {
            //Stack<T> stack2 = new Stack<T>();//Hata çünkü program çalışırken  açık tip olmamalıdır.


            Stack<int> stack = new Stack<int>();//Burada int string gibi formatlar kapalı tiptir ve program çalışırken bir bir hata vermez.
            /*Stack<int> stack = new Stack<int>(); yazınca aslında aşağıdaki gibi bir classtan eleman üretmiş oluyoruz.
           
            public class ###
            {
            int position;
            int[] data = new int[100];
            public void Push(int obj) { data[position++] = obj; }
            public int Pop() { return data[--position]; }
             }
            */


            stack.Push(5);
            stack.Push(10);
            int x = stack.Pop();
            int y = stack.Pop();

            Console.WriteLine(x);
            Console.WriteLine(y);

            Console.ReadKey();
        }
    }
}