C# Academy · Ders

Yerel İşlevler ve Lambda'lar

Yerel işlevler ile lambda'lar arasında seçim yapın.

Yerel İşlevler ve Lambda'lar, CoddyKit'te ücretsiz bir C# Academy dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, C# Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. C# Academy kursu toplamda 4 dersten oluşur.

Yerel İşlevler ve Lambdalar

Hem yerel işlevler hem de lambdalar, bir yöntemin içinde küçük işlevler tanımlamanızı sağlar. Birbirleriyle büyük ölçüde örtüşseler de söz dizimi, yetenekleri ve performansları farklıdır. Doğru olanı seçmek kodu anlaşılır ve verimli tutar.

Yardımcı Yazmanın İki Yolu

Burada aynı kare alma yardımcısı hem yerel işlev hem de bir temsilciye atanmış lambda olarak yazılmıştır. Her ikisi de aynı sonucu üretir.

using System;

public class Program
{
    public static void Main()
    {
        int SquareFn(int n) => n * n;       // local function
        Func<int, int> squareLambda = n => n * n; // lambda

        Console.WriteLine(SquareFn(4));
        Console.WriteLine(squareLambda(4));
    }
}

Yerel İşlevler Özyinelemeye Kolayca İzin Verir

Bir yerel işlev kendisini adıyla çağırabilir. Bir lambda, başlatılması sırasında kendi değişkenine başvuramaz; bu nedenle lambdalarla özyineleme kullanmak zahmetlidir.

using System;

public class Program
{
    public static void Main()
    {
        // Clean recursion with a local function
        int Factorial(int n) => n <= 1 ? 1 : n * Factorial(n - 1);
        Console.WriteLine(Factorial(5));
    }
}

Yerel İşlevler Genel Olabilir

Yerel işlevler kendi tür parametrelerini destekler. Lambdalar genel olamaz; bu nedenle yeniden kullanılabilir, türü belirlenmiş yardımcılar için yerel işlev doğru seçimdir.

using System;

public class Program
{
    public static void Main()
    {
        T First<T>(T[] items) => items[0]; // generic local function

        Console.WriteLine(First(new[] { 9, 8, 7 }));
        Console.WriteLine(First(new[] { "a", "b" }));
    }
}

Performans: Temsilci Ayırmasından Kaçınma

Bir temsilciye atanan lambda, bir temsilci nesnesi ve yakalama yapıyorsa bir kapanım ayırabilir. Doğrudan çağrılan bir yerel işlev her ikisinden de kaçınır; bu, yoğun döngülerde önemlidir.

using System;

public class Program
{
    public static void Main()
    {
        // Direct call, no delegate or closure allocation
        static int Add(int a, int b) => a + b;

        int total = 0;
        for (int i = 0; i < 5; i++) total = Add(total, i);
        Console.WriteLine(total);
    }
}

out ve ref Parametreleri

Yerel işlevler out ve ref parametrelerini tanımlayabilir; yaygın Func/Action temsilcileri aracılığıyla kullanılan lambdalar bunu yapamaz. Bu nedenle try-parse yardımcılarını yerel işlevler olarak yazmak doğaldır.

using System;

public class Program
{
    public static void Main()
    {
        bool TryGetFirstDigit(string s, out int digit)
        {
            digit = 0;
            foreach (var c in s)
                if (char.IsDigit(c)) { digit = c - '0'; return true; }
            return false;
        }

        if (TryGetFirstDigit("abc4", out int d))
            Console.WriteLine(d);
    }
}

Lambda İfadeleri Satır İçi Bağımsız Değişkenler Olarak Öne Çıkar

LINQ Where veya Select gibi bir yönteme davranışı doğrudan aktarmanız gerektiğinde, lambda ifadesi en kısa ve okunabilir seçenektir.

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

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3, 4, 5, 6 };
        var evens = nums.Where(n => n % 2 == 0).Select(n => n * 10);
        Console.WriteLine(string.Join(", ", evens));
    }
}

Her İkisinde de Değişken Yakalama Mümkündür

Her iki biçim de çevreleyen değişkenleri yakalayabilir. Aralarındaki fark, yakalamanın mümkün olup olmamasından çok sözdiziminde ve bellek ayırma maliyetindedir.

using System;

public class Program
{
    public static void Main()
    {
        int bonus = 10;
        int WithBonusFn(int n) => n + bonus;     // captures
        Func<int, int> withBonusLambda = n => n + bonus; // captures

        Console.WriteLine(WithBonusFn(5));
        Console.WriteLine(withBonusLambda(5));
    }
}

Kesin Atama ve Sıra

Yerel bir işlev, yöntemdeki bildiriminden önce çağrılabilir; lambda değişkenine ise kullanılmadan önce değer atanmalıdır. Bu, yerel işlevlerin daha esnek konumlandırılmasını sağlar.

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Triple(4)); // allowed before declaration

        int Triple(int n) => n * 3;
    }
}

Aralarında Seçim Yapma

Adlandırılmış, yeniden kullanılabilir, özyinelemeli, genel veya kritik yol yardımcıları için yerel işlev kullanın. Başka bir yönteme doğrudan aktarılan kısa, satır içi davranış için lambda ifadesi kullanın. Her ikisi de birer araçtır; seçiminizi amacınıza göre yapın.

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

public class Program
{
    public static void Main()
    {
        static bool IsPrime(int n)
        {
            if (n < 2) return false;
            for (int i = 2; i * i <= n; i++)
                if (n % i == 0) return false;
            return true;
        }

        var primes = Enumerable.Range(2, 20).Where(IsPrime);
        Console.WriteLine(string.Join(", ", primes));
    }
}

Kendiniz Deneyin

Temel mantık için özyinelemeli bir yerel işlev, satır içi LINQ dönüşümü içinse bir lambda ifadesi kullanarak her yapının en iyi yaptığı işi yapmasını sağlayın.

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

public class Program
{
    public static void Main()
    {
        // Local function: recursive, named, reusable
        static int DigitCount(int n) => Math.Abs(n) < 10 ? 1 : 1 + DigitCount(n / 10);

        var nums = new List<int> { 5, 42, 1000, 7, 88 };
        // Lambda: concise inline projection
        var report = nums.Select(n => n + " has " + DigitCount(n) + " digits");
        foreach (var line in report) Console.WriteLine(line);
    }
}

Kısa Kontrol

İki yapıyı karşılaştırın.

Özet

Yerel işlevler ve lambda ifadeleri benzer özelliklere sahip olsa da bazı önemli yönlerden farklıdır.

Yerel işlevler özyinelemeli ve genel olabilir, ayrıca out/ref kullanabilir.
Doğrudan çağrıldıklarında temsilci ve kapanım için bellek ayırmazlar.
Lambda ifadeleri, LINQ gibi yöntemlere satır içi bağımsız değişken olarak aktarıldıklarında en kısa biçimdedir.
Seçiminizi amacınıza göre yapın: adlandırılmış, yeniden kullanılabilir yardımcı ya da kısa, satır içi davranış.

Sıkça Sorulan Sorular

“Yerel İşlevler ve Lambda'lar” dersi ücretsiz mi?

Evet — “Yerel İşlevler ve Lambda'lar” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve C# Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. C# Academy kursu toplamda 4 dersten oluşur.

“Yerel İşlevler ve Lambda'lar” dersinde ne öğreneceğim?

Yerel işlevler ile lambda'lar arasında seçim yapın. C# Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

C# Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te C# Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Yerel İşlevler ve Lambda'lar” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu C# Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her C# Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← C# Academy Sayfasına Dön