C#'ta Predicate nedir?

Bir T alıp bool döndüren, Func ile aynı şekle sahip bir delegate tipidir. Func'tan daha eskidir ve List .Find, FindAll, RemoveAll, Exists ve Array.Find tarafından kullanılır. İki tip birbirine dönüşmez, ama bir lambda ikisine de dönüşür.

Çalıştırılabilir C# Dokümanları: Func ve Action

Q: C#'ta Func ile Action arasındaki fark nedir?

Func bir değer döndürür, Action döndürmez. Func 'da son tip argümanı (bool) dönüş tipidir, diğerleri parametrelerdir. Action bir int ve bir string alır ve void döndürür. İkisinin de 0 ile 16 parametreli sürümleri vardır.

Q: C#'ta bir fonksiyon parametre olarak nasıl geçirilir?

Parametreyi doğru şekilde bir Func ya da Action olarak bildirin ve metodun içinde çağırın: static decimal Apply(decimal price, Func rule) => rule(price);. Çağıranlar bir lambda (Apply(80m, p => p * 0.9m)) ya da bir metot adı (Apply(80m, HalfPrice)) geçirir.

Q: Func async kodla nasıl kullanılır?

Sonucu olmayan async bir fonksiyon için Func , sonucu olan için Func > kullanın; böylece çağıran onu await edebilir. Async bir lambda'yı bir Action'a atamaktan kaçının: bu onu async void yapar; await edilemez ve istisnaları çağıran tarafından yakalanamaz.

Q: Func'ın out ya da ref parametreleri olabilir mi?

Hayır. Func ve Action'ın generic parametreleri sıradan değer parametreleridir, bu yüzden Func yazmanın bir yolu yoktur. TryParse gibi bir imza için özel bir delegate bildirin: delegate bool TryParser (string text, out T value);.

Func ve Action, .NET'in sizin için bildirdiği generic delegate tipleridir; böylece önce bir delegate tipi bildirmeden fonksiyonları saklayıp geçirebilirsiniz. Func bir değer döndürür; Action hiçbir şey döndürmez.

using System;

class Program
{
    static void Main()
    {
        Func<int> rollFixed = () => 4;
        Func<decimal, decimal> addTip = bill => bill * 1.15m;
        Func<int, int, bool> canAfford = (budget, price) => budget >= price;

        Action greet = () => Console.WriteLine("Hello!");
        Action<string, int> report = (name, score) => Console.WriteLine($"{name} scored {score}");

        Console.WriteLine(rollFixed());
        Console.WriteLine(addTip(40m));
        Console.WriteLine(canAfford(100, 120));
        greet();
        report("Mia", 87);
    }
}

Çıktı:

4
46.00
False
Hello!
Mia scored 87

Hatırlanacak kural: bir Func'ta son tip argümanı dönüş tipidir. Func<int, int, bool> iki int alır ve bir bool döndürür. Func<int> hiçbir şey almaz ve bir int döndürür. Bir Action'ın tip argümanlarının hepsi parametredir.

Aile

Tip	Parametreler	Döndürür
`Action`	yok	`void`
`Action<T>`	`T`	`void`
`Action<T1, T2>` ... 16'ya kadar	`T1, T2, ...`	`void`
`Func<TResult>`	yok	`TResult`
`Func<T, TResult>`	`T`	`TResult`
`Func<T1, T2, TResult>` ... 16'ya kadar	`T1, T2, ...`	`TResult`
`Predicate<T>`	`T`	`bool`
`Comparison<T>`	`T, T`	`int` (negatif, sıfır, pozitif)
`Converter<TIn, TOut>`	`TIn`	`TOut`

Predicate, Comparison ve Converter daha eskidir ve List<T> ile Array metotlarında görünür: FindAll(Predicate<T>), Sort(Comparison<T>), ConvertAll(Converter<T, TOut>). LINQ her yerde Func kullanır; list.Where(...) ile list.FindAll(...)'ın aynı şekilde ama farklı tiplerde lambda almasının nedeni budur:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var ages = new List<int> { 34, 17, 52, 15, 28 };

        Predicate<int> isMinor = a => a < 18;
        Func<int, bool> isAdult = a => a >= 18;
        Comparison<int> descending = (x, y) => y.CompareTo(x);

        Console.WriteLine(string.Join(", ", ages.FindAll(isMinor)));
        Console.WriteLine(string.Join(", ", ages.Where(isAdult)));

        ages.Sort(descending);
        Console.WriteLine(string.Join(", ", ages));

        List<string> labels = ages.ConvertAll(a => $"{a}y");
        Console.WriteLine(string.Join(" ", labels));
    }
}

Çıktı:

17, 15
34, 52, 28
52, 34, 28, 17, 15
52y 34y 28y 17y 15y

Metotlara Fonksiyon Geçirmek

Bir Func ya da Action parametresi, algoritmanın değişen kısmını çağıranın sağlamasına izin verir. İki yaygın şekil "bunu çalıştır ve ölç" ile "işe yarayana kadar bunu dene"dir:

using System;

class Program
{
    static T Retry<T>(Func<int, T> attempt, int maxTries)
    {
        for (int i = 1; i <= maxTries; i++)
        {
            try
            {
                return attempt(i);
            }
            catch (InvalidOperationException)
            {
                Console.WriteLine($"attempt {i} failed");
            }
        }
        throw new InvalidOperationException("all attempts failed");
    }

    static void Twice(Action work)
    {
        work();
        work();
    }

    static void Main()
    {
        string page = Retry(n =>
        {
            if (n < 3) throw new InvalidOperationException();
            return "<html>ok</html>";
        }, maxTries: 5);
        Console.WriteLine(page);

        int clicks = 0;
        Twice(() => clicks++);
        Console.WriteLine($"clicks: {clicks}");
    }
}

Çıktı:

attempt 1 failed
attempt 2 failed
<html>ok</html>
clicks: 2

Retry generic'tir, bu yüzden Func<int, T>'si her şeyi döndürebilir; derleyici T'yi lambda'dan string olarak çıkardı. Twice'a geçirilen lambda yerel clicks'i değiştirir; bu, bir lambda'nın değerinin bir kopyasını değil değişkenin kendisini yakaladığı için çalışır.

Metot Grupları: Bir Metodu Adıyla Geçirmek

Bir Func ya da Action'ı doldurmak için lambda'ya ihtiyacınız yoktur. İmzası uyan mevcut bir metodun adı (bir "metot grubu") doğrudan dönüşür:

using System;
using System.Linq;

class Program
{
    static bool IsWeekendCode(string day) => day == "sat" || day == "sun";

    static void Main()
    {
        Func<string, int> parse = int.Parse;
        Func<string, bool> weekend = IsWeekendCode;
        Action<string> print = Console.WriteLine;

        string[] quantities = { "3", "10", "7" };
        int total = quantities.Select(int.Parse).Sum();

        print($"parsed: {parse("42") + 1}");
        print($"sat is weekend: {weekend("sat")}");
        print($"total quantity: {total}");
    }
}

Çıktı:

parsed: 43
sat is weekend: True
total quantity: 20

Select(int.Parse), bir çağrı katmanı eksiğiyle Select(s => int.Parse(s)) ile aynıdır. Derleyici hedef tipe uyan overload'u seçer: int.Parse'ın birkaç overload'u vardır ve yalnızca Parse(string) Func<string, int> ile eşleşir. Derleyici birine karar veremediğinde (birkaç overload eşit derecede uyduğunda ya da generic bir metodun tip argümanları bir metot grubundan çıkarılamadığında) çağrı derlenmez ve çağrıyı açık hale getiren bir lambda sorunu çözer.

Bir Func olarak kullanılan bir metot grubu da, tıpkı bir lambda gibi, delegate her çağrıldığında sonradan çalışır. Fark yalnızca nasıl yazıldığındadır.

Fonksiyon Döndürmek

Bir metot bir fonksiyon oluşturup döndürebilir. Döndürülen Func, oluşturulduğu değerleri taşır:

using System;

class Program
{
    static Func<decimal, decimal> PercentOff(decimal percent) =>
        price => price - price * percent / 100m;

    static Func<T, T> Twice<T>(Func<T, T> f) => x => f(f(x));

    static void Main()
    {
        Func<decimal, decimal> blackFriday = PercentOff(30m);
        Func<decimal, decimal> staff = PercentOff(10m);

        Console.WriteLine(blackFriday(200m));
        Console.WriteLine(staff(200m));
        Console.WriteLine(Twice(staff)(200m));
    }
}

Çıktı:

140
180
162

Twice(staff), personel indirimini iki kez uygulayan yeni bir fonksiyon oluşturur: 200, sonra 180, sonra 162.

Fonksiyonlardan Oluşan Bir Dictionary

Fonksiyonları bir dictionary'de saklamak uzun bir switch'i bir arama tablosuna çevirir. Komut işleyicileri, hesap makineleri ve menü eylemleri için olağan şekil budur ve çalışma zamanında yeni girdiler eklenebilir:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var operations = new Dictionary<string, Func<decimal, decimal, decimal>>
        {
            ["+"] = (a, b) => a + b,
            ["-"] = (a, b) => a - b,
            ["*"] = (a, b) => a * b,
            ["/"] = (a, b) => b == 0 ? throw new DivideByZeroException() : a / b,
        };

        var commands = new Dictionary<string, Action<string>>(StringComparer.OrdinalIgnoreCase)
        {
            ["greet"] = arg => Console.WriteLine($"Hello, {arg}"),
            ["shout"] = arg => Console.WriteLine(arg.ToUpper()),
        };

        string[] inputs = { "12 + 30", "7 * 6", "9 / 0", "2 ^ 3" };
        foreach (string input in inputs)
        {
            string[] p = input.Split(' ');
            Func<decimal, decimal, decimal> op;
            if (!operations.TryGetValue(p[1], out op))
            {
                Console.WriteLine($"{input} = unknown operator");
                continue;
            }
            try
            {
                Console.WriteLine($"{input} = {op(decimal.Parse(p[0]), decimal.Parse(p[2]))}");
            }
            catch (DivideByZeroException)
            {
                Console.WriteLine($"{input} = cannot divide by zero");
            }
        }

        commands["GREET"]("Sam");
        commands["shout"]("done");
    }
}

Çıktı:

12 + 30 = 42
7 * 6 = 42
9 / 0 = cannot divide by zero
2 ^ 3 = unknown operator
Hello, Sam
DONE

Bir operatör eklemek, döngüde hiçbir değişiklik olmadan bir dictionary girdisi daha demektir. İkinci dictionary'ye geçirilen StringComparer.OrdinalIgnoreCase komut adlarını harf duyarsız yapar.

Async Fonksiyonlar: Action Değil Func<Task>

async kodda delegate tipi, çağıranın işi bekleyip bekleyemeyeceğine karar verir:

Func<Task> save = async () => await File.WriteAllTextAsync("a.txt", "data");
await save();                       // the caller can await it and see its exceptions

Func<int, Task<string>> load = async id => await FetchUserAsync(id);
string user = await load(42);

Action bad = async () => await File.WriteAllTextAsync("a.txt", "data");
bad();                              // async void: fire and forget, exceptions escape

Bir Action'a atanan async bir lambda bir async void metodu olur: hiçbir şey onu await edemez ve içindeki bir istisna asla çağırana ulaşmaz. Thread pool'da (ya da bir masaüstü uygulamasında UI thread'inde) yeniden fırlatılır ve orada genellikle süreci çökertir. Async iş kabul eden bir metot yazdığınızda bir Func<Task> (ya da Func<Task<T>>) alın.

Kendi Delegate'inizi Ne Zaman Bildirmelisiniz

Func ve Action çoğu ihtiyacı karşılar. Şu durumlarda adlandırılmış bir delegate tipi bildirin:

İmzada ref, out ya da in parametreleri var. Func bunları ifade edemez, bu yüzden TryParse tarzı bir fonksiyon delegate bool TryParser<T>(string text, out T value); gerektirir.
Ad, public bir API'de bir rolü belgeliyor. Bir metot imzasındaki delegate bool Validator(string input), Func<string, bool>'dan daha fazlasını söyler ve parametre adları IntelliSense'te görünür.
Bir params parametresine ihtiyacınız var; generic delegeler bunu da içeremez.

Özel delegate tiplerinin hâlâ göründüğü diğer yer event'lerdir, ama yerleşik EventHandler<TEventArgs> çoğunu karşılar. Delegeler sayfası delegate tiplerini bildirmeyi ve birleştirmeyi ele alır.

Sıkça Sorulan Sorular

C#'ta Func ile Action arasındaki fark nedir?

Func bir değer döndürür, Action döndürmez. Func<int, string, bool>'da son tip argümanı (bool) dönüş tipidir, diğerleri parametrelerdir. Action<int, string> bir int ve bir string alır ve void döndürür. İkisinin de 0 ile 16 parametreli sürümleri vardır.

C#'ta bir fonksiyon parametre olarak nasıl geçirilir?

Parametreyi doğru şekilde bir Func ya da Action olarak bildirin ve metodun içinde çağırın: static decimal Apply(decimal price, Func<decimal, decimal> rule) => rule(price);. Çağıranlar bir lambda (Apply(80m, p => p * 0.9m)) ya da bir metot adı (Apply(80m, HalfPrice)) geçirir.

C#'ta Predicate<T> nedir?

Bir T alıp bool döndüren, Func<T, bool> ile aynı şekle sahip bir delegate tipidir. Func'tan daha eskidir ve List<T>.Find, FindAll, RemoveAll, Exists ve Array.Find tarafından kullanılır. İki tip birbirine dönüşmez, ama bir lambda ikisine de dönüşür.

Func async kodla nasıl kullanılır?

Sonucu olmayan async bir fonksiyon için Func<Task>, sonucu olan için Func<T, Task<TResult>> kullanın; böylece çağıran onu await edebilir. Async bir lambda'yı bir Action'a atamaktan kaçının: bu onu async void yapar; await edilemez ve istisnaları çağıran tarafından yakalanamaz.

Func'ın out ya da ref parametreleri olabilir mi?

Hayır. Func ve Action'ın generic parametreleri sıradan değer parametreleridir, bu yüzden Func<string, out int, bool> yazmanın bir yolu yoktur. TryParse gibi bir imza için özel bir delegate bildirin: delegate bool TryParser<T>(string text, out T value);.

İlgili kavramlar