Delegate etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster
Delegate etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster

6 Mart 2018

C# Func Nedir?

using System;
using System.Linq;

namespace IEnumerableDemo
{
    public delegate int SomeOperation(int x, int y);
    class Program
    {
        static int Sum(int x, int y) => x + y;

        static void Main(string[] args)
        {


            //Örnek SomeOperation iki int girdi alarak int döndüren bir delegatedir. 
            //Burada SomeOperation türüne add metodunu tanımladık.
            SomeOperation add = Sum;
            Console.WriteLine(add(10, 10));
            /*
             ÇIKTI:
             20
             */


            //Func .net içerisine eklenmiş hazır delegate metodlardır.
            //public delegate TResult Func<in T, out TResult>(T arg); gibi 16 girdi 
            //ve bir çıktıya kadar destekleyecek şekilde tanımlanmış generic bir delgatedir.
            //Yukarıda delegate tanımlayarak yaptığımız işlemi delegate
            //tanımlamadan hazır Func delegatesini kullanarak yazdık;
            Func<int, int, int> addF = Sum;
            Console.WriteLine(addF(10, 10));
            /*
             ÇIKTI:
             20
             */

            //Lambda Fonksiyonları da aslında birer delegate metodlardır.
            //Örnekler 
            Func<int, string> func1 = (x) => string.Format("string = {0}", x);
            Func<bool, int, string> func2 = (b, x) => string.Format("string = {0} and {1}", b, x);
            Func<double> func3 = () => Math.PI / 2.0;
            Func<int> getRandomNumber = () =>
            {
                var r = new Random().Next(1, 100);
                return r;
            };

            Console.WriteLine(func1.Invoke(1));
            Console.WriteLine(func2.Invoke(true, 2));
            Console.WriteLine(func3.Invoke());
            /*
            ÇIKTI:
            string = 1
            string = True and 2
            1,5707963267949
            */
            Console.WriteLine(getRandomNumber());



            //Kullanımı için lambda fonksiyonları güzel bir örnektir.
            //Yazılabilecek filtreleme ve seçimi işleme işlemlerini
            //Func ile yazarak çeşitli yerlerde kulllanabiliriz..

            //Filtreleme için yazıldı. Çift Sayıları Seç
            Func<int, bool> evenNumbers = (x) => x % 2 == 0;

            //Seçimi İşleme Tersine Çevir ve String Türüne Dönüştür.
            Func<int, string> reciprocal = (x) => $"{ x } + {-1 * x} = 0";

            int[] values = { 1, 2, 3, 4, 5, 6 };
            var res = values.Where(evenNumbers).Select(reciprocal);
            foreach (var item in res)
                Console.WriteLine(item);
            /*
           ÇIKTI:
            2 + -2 = 0
            4 + -4 = 0
            6 + -6 = 0
           */
        }
    }
}


7 Şubat 2018

C# Delegates Örnek

using System;

namespace DelegateDemo
{
    public enum CallState
    {
        Ringing,
        Answered,
        Parked,
        Closed
    }
    public class CallArgs
    {
        public DateTime Time => DateTime.Now;
        public CallState State { get; set; }
        public string PhoneNumber { get; set; }
        public CallArgs(CallState state, string phoneNumber)
        {
            State = state;
            PhoneNumber = phoneNumber;
        }
    }

    public delegate void CallStateHandler(object sender, CallArgs args);

    public class Line
    {
        public string PhoneNumber { get; set; }

        public event CallStateHandler LineStateChanged;
        private CallState state;
        public CallState State {
            get {
                return state;
            }
            set {
                state = value;
                if (LineStateChanged != null)
                    LineStateChanged(this, new CallArgs(value, PhoneNumber));
            }
        }

        public Line(string phoneNumber, CallState state)
        {
            LineStateChanged += CallStateChanged;
            PhoneNumber = phoneNumber;
            State = state;
                              
        }

        private void CallStateChanged(object sender, CallArgs args)
        {
            if (args.State == CallState.Ringing)
                Console.WriteLine($"{args.Time} => {args.PhoneNumber} hat çalıyor ");
            else if (args.State == CallState.Answered)
                Console.WriteLine($"{args.Time} => {args.PhoneNumber} hat açıldı ");
            else if (args.State == CallState.Parked)
                Console.WriteLine($"{args.Time} => {args.PhoneNumber} hat beklemede ");
            else if (args.State == CallState.Closed)
            {
                PhoneNumber = string.Empty;
                Console.WriteLine($"{args.Time} => hat kapalı");

            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {            
            var line = new Line("00000000", CallState.Ringing);
            line.State = CallState.Answered;
            line.State = CallState.Parked;
            line.State = CallState.Closed;
            Console.WriteLine(line.PhoneNumber);
        }
    }
}

9 Eylül 2015

Delegates 6 : Delegate Compability(Uyumluluk)

Type compability:

using System;

namespace DelegateCompatibility
{
    class Program
    {
        delegate void D1();
        delegate void D2();

        static void Method1(){}
        static void Main(string[] args)
        {
            D1 d1 = Method1;
            //D2 d2 = d1;//!Hata delegate ler birbirileriyle uymsuzdur.Bu yüzden hata verir.
            //Ama aşağıdaki gibi tanımlayabiliriz.
            D2 d2 = new D2(d1);

            //Eğer aynı delegateler aynı sırayla aynı methodlara sahiblerse bunlar birbirlerine eşit sayılabilirler.
            //Örneğin
            D1 d3 = Method1;

            Console.WriteLine(d1 == d3);//True

            Console.ReadKey();

        }
    }
}
 Parameter compability:

 Contravariance özelliğini sağlamaktadır. Aşağıdaki örnekte string türü olan bir methoda object türü de uygulanabilmektedir.

using System;

namespace DelegateCompatibility
{
    class Program
    {
        delegate void StringAction(string s);

        static void ActionOnObject(object o)
        {
            Console.WriteLine(o);//Hello
        }
        static void Main(string[] args)
        {
            StringAction sa = new StringAction(ActionOnObject);
            sa("Hello");
        }
    }
}
 Return type compability:

Covariance özelliğini sağlamaktadır.  Aşağıdaki örnekte görüldüğü gibi object türünde bir delegate string metdounu desteklemektedir.

using System;

namespace DelegateCompatibility
{
    class Program
    {
        delegate object ObjectRetriever();
        static string RetriveString() { return "hello"; }
        static void Main(string[] args)
        {
            ObjectRetriever or = new ObjectRetriever(RetriveString);
            object result = or();
            Console.WriteLine(result);

            Console.ReadKey();
        }
    }




Not:
Contravariance alt kümeden üst kümeyi desteklemesi durumudur.(string-->object)
Covariance    üst kümenin alt kümeyi sağlaması durumudur.(object-->string)

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();
        }
    }
}