C# Academy · Ders

Kapanışlar ve Yakalanan Değişkenler

Yerel işlevlerin durumu nasıl yakaladığını görün.

Kapanışlar ve Yakalanan Değişkenler, CoddyKit'te ücretsiz bir C# Academy dersidir. Bu, 4 dersinin 2. 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 Durum Üzerindeki Kapanımlar

Bir yerel işlev (veya lambda), kendisini kapsayan yöntemdeki değişkenleri okuyabilir ve değiştirebilir. Buna yakalama denir; işlev ile yakaladığı değişkenler birlikte bir kapanım oluşturur.

Bir Değişkeni Yakalama

Yerel işlev, kendisini kapsayan yöntemdeki factor değişkenini doğrudan kullanır. Bu değişkeni parametre olarak almaz; çevresindeki kapsamdan yakalar.

using System;

public class Program
{
    public static void Main()
    {
        int factor = 3;
        int Scale(int n) => n * factor; // captures factor

        Console.WriteLine(Scale(5));
        Console.WriteLine(Scale(10));
    }
}

Yakalanan Değişkenler Canlı Başvurulardır

Bir kapanım, değerinin anlık görüntüsünü değil değişkeni yakalar. İşlev tanımlandıktan sonra değişken değişirse işlev yeni değeri görür.

using System;

public class Program
{
    public static void Main()
    {
        int offset = 10;
        int Add(int n) => n + offset;

        Console.WriteLine(Add(1)); // 11
        offset = 100;
        Console.WriteLine(Add(1)); // 101 - sees updated offset
    }
}

Yakalanan Değişkenleri Değiştirme

Bir kapanım, yakalanan bir değişkene yazabilir ve bu değişiklik kendisini kapsayan yöntemde de görünür. Bu özellik, kapanımları durum biriktirmek için kullanışlı kılar.

using System;

public class Program
{
    public static void Main()
    {
        int count = 0;
        void Tick() => count++;

        Tick(); Tick(); Tick();
        Console.WriteLine(count); // 3
    }
}

Kapanım Döndürme

Yerel değişkenleri yakalayan bir lambda döndürdüğünüzde, bu değişkenler yöntemi aşan bir yaşam süresine sahip olur. Yakalanan durum, temsilci var olduğu sürece yaşar.

using System;

public class Program
{
    static Func<int> MakeCounter()
    {
        int count = 0;
        return () => ++count; // captures count
    }

    public static void Main()
    {
        var next = MakeCounter();
        Console.WriteLine(next());
        Console.WriteLine(next());
        Console.WriteLine(next());
    }
}

Bağımsız Kapanımlar

Bir fabrika işlevine yapılan her çağrı, yakalanan değişkenlerden oluşan yeni bir küme oluşturur. Bu şekilde oluşturulan iki sayaç birbirini etkilemez.

using System;

public class Program
{
    static Func<int> MakeCounter()
    {
        int count = 0;
        return () => ++count;
    }

    public static void Main()
    {
        var a = MakeCounter();
        var b = MakeCounter();
        Console.WriteLine(a()); // 1
        Console.WriteLine(a()); // 2
        Console.WriteLine(b()); // 1 - separate state
    }
}

foreach Yakalama Düzeltmesi

Modern C# sürümlerinde foreach döngü değişkeni her yinelemede yenidir; bu nedenle kapanımlar beklenen değeri yakalar. Aşağıdaki her lambda kendi öğesini hatırlar.

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        var actions = new List<Action>();
        foreach (var i in new[] { 1, 2, 3 })
            actions.Add(() => Console.WriteLine(i));

        foreach (var act in actions) act(); // prints 1, 2, 3
    }
}

for Döngüsünde Yakalama

Klasik bir tuzak şudur: tek bir for döngü değişkeni yinelemeler arasında paylaşılır; bu nedenle tüm kapanımlar değişkenin son değerini görür. Farklı değerleri yakalamak için değişkeni her yinelemeye özgü bir yerel değişkene kopyalayın.

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        var actions = new List<Action>();
        for (int i = 0; i < 3; i++)
        {
            int copy = i; // fresh local each iteration
            actions.Add(() => Console.WriteLine(copy));
        }
        foreach (var act in actions) act(); // prints 0, 1, 2
    }
}

Kapanımlar Değeri Değil Başvuruyu Yakalar

Yakalama başvuru yoluyla yapıldığından, yakalamadan sonra özgün değişkende yapılan değişiklik kapanım tarafından görülür. Okuma ve yazmaların zamanlamasının önemli olduğu durumlarda bunu unutmayın.

using System;

public class Program
{
    public static void Main()
    {
        string message = "first";
        Action print = () => Console.WriteLine(message);

        print();          // first
        message = "second";
        print();          // second
    }
}

Pratik Kullanım: Yapılandırılabilir Davranış

Kapanımlar, bağlamla önceden yüklenmiş küçük işlevler oluşturmanızı sağlar. Burada bir indirim işlevi bir oranı yaklayarak yeniden kullanılabilir, yapılandırılmış bir hesaplayıcı üretir.

using System;

public class Program
{
    static Func<double, double> MakeDiscount(double rate)
        => price => price * (1 - rate);

    public static void Main()
    {
        var tenOff = MakeDiscount(0.10);
        var halfOff = MakeDiscount(0.50);
        Console.WriteLine(tenOff(100));
        Console.WriteLine(halfOff(100));
    }
}

Kendiniz Deneyin

Döndürülen kapanımın özel durumu canlı tutmasını sağlayan bir sayaç fabrikası oluşturun, ardından bundan iki bağımsız sayaç üretin.

using System;

public class Program
{
    static Func<int> MakeStepper(int step)
    {
        int current = 0;
        return () => { current += step; return current; }; // captures current and step
    }

    public static void Main()
    {
        var byTwos = MakeStepper(2);
        var byTens = MakeStepper(10);
        Console.WriteLine(byTwos()); // 2
        Console.WriteLine(byTwos()); // 4
        Console.WriteLine(byTens()); // 10 - separate state
    }
}

Hızlı Kontrol

Yakalamanın nasıl çalıştığı üzerine düşünün.

Özet

Kapanımlar, kendilerini kapsayan değişkenleri başvuru yoluyla yakalar.

İşlev, daha sonra yapılan değişiklikler de dâhil olmak üzere değişkenin güncel değerini görür.
Yakalanan değişkenleri değiştirebilir ve yöntemle durumu paylaşabilir.
Döndürülen kapanımlar, yakaladıkları değişkenleri canlı tutar.
Farklı değerleri yakalamak için for döngüsünde her yinelemeye özgü bir yerel değişken kullanın.

Sıkça Sorulan Sorular

“Kapanışlar ve Yakalanan Değişkenler” dersi ücretsiz mi?

Evet — “Kapanışlar ve Yakalanan Değişkenler” 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.

“Kapanışlar ve Yakalanan Değişkenler” dersinde ne öğreneceğim?

Yerel işlevlerin durumu nasıl yakaladığını görü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 2. dersidir.

“Kapanışlar ve Yakalanan Değişkenler” 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