Yerel işlevler (C# Programlama Kılavuzu)

Yerel işlevler , başka bir üyede iç içe yerleştirilmiş bir türün yöntemleridir. Bunlar yalnızca kendi içeren üyelerinden çağrılabilir. Yerel işlevler içinde bildirilebilir ve şu kaynaktan çağrılabilir:

• Yöntemler, özellikle yineleyici yöntemler ve zaman uyumsuz yöntemler
• Oluşturucular
• Özellik erişimcileri
• Olay erişimcileri
• Anonim yöntemler
• Lambda ifadeleri
• Sonlandırıcılar
• Diğer yerel işlevler

Ancak, yerel işlevler ifade gövdeli bir üye içinde bildirilemiyor.

Yerel işlevler kodunuzun amacını net hale getirir. Kodunuzu okuyan herkes, yöntemin yalnızca içeren yöntem tarafından çağrılabildiğini görebilir. Ekip projeleri için, başka bir geliştiricinin yöntemi doğrudan sınıfın veya yapının başka bir yerinden yanlışlıkla çağırmasını da imkansız hale getirir.

Yerel işlev söz dizimi

Yerel işlev, içeren bir üyenin içinde iç içe yerleştirilmiş bir yöntem olarak tanımlanır. Tanımı aşağıdaki söz dizimine sahiptir:

<modifiers> <return-type> <method-name> <parameter-list>

Aşağıdaki değiştiricileri yerel bir işlevle kullanabilirsiniz:

• async
• unsafe
• static Statik bir yerel işlev yerel değişkenleri veya örnek durumunu yakalayamaz.
• extern Dış yerel işlev olmalıdır static.

Yöntem parametreleri dahil olmak üzere, içeren üyede tanımlanan tüm yerel değişkenlere statik olmayan bir yerel işlevde erişilebilir.

Yöntem tanımından farklı olarak, yerel işlev tanımı üye erişim değiştiricisini içeremez. private anahtar sözcüğü gibi bir erişim değiştirici de dahil olmak üzere tüm yerel işlevler özel olduğundan, "'özel' değiştirici bu öğe için geçerli değil" derleyici hatası CS0106 oluşturur.

Aşağıdaki örnek adlı bir yöntemin özel olduğu adlı AppendPathSeparatorGetTextbir yerel işlevi tanımlar:

private static string GetText(string path, string filename)
{
     var reader = File.OpenText($"{AppendPathSeparator(path)}{filename}");
     var text = reader.ReadToEnd();
     return text;

     string AppendPathSeparator(string filepath)
     {
        return filepath.EndsWith(@"\") ? filepath : filepath + @"\";
     }
}

Aşağıdaki örnekte gösterildiği gibi yerel işleve, parametrelerine ve tür parametrelerine öznitelikler uygulayabilirsiniz:

#nullable enable
private static void Process(string?[] lines, string mark)
{
    foreach (var line in lines)
    {
        if (IsValid(line))
        {
            // Processing logic...
        }
    }

    bool IsValid([NotNullWhen(true)] string? line)
    {
        return !string.IsNullOrEmpty(line) && line.Length >= mark.Length;
    }
}

Yukarıdaki örnek, derleyicinin boş değer atanabilir bir bağlamda statik çözümlemede yardımcı olması için özel bir öznitelik kullanır.

Yerel işlevler ve özel durumlar

Yerel işlevlerin kullanışlı özelliklerinden biri, özel durumların hemen ortaya çıkışına izin verebilmeleridir. Yineleyici yöntemleri için özel durumlar yalnızca döndürülen sıra numaralandırıldığında ortaya çıkar ve yineleyici alındığında gösterilmez. Zaman uyumsuz yöntemler için, döndürülen görev beklenirken zaman uyumsuz bir yöntemde oluşan özel durumlar gözlemlenir.

Aşağıdaki örnek, belirtilen aralıktaki tek sayıları numaralandıran bir yöntemi tanımlar OddSequence . Numaralandırıcı yöntemine 100'den büyük bir sayı geçirdiğinden OddSequence , yöntemi bir ArgumentOutOfRangeExceptionoluşturur. Örnekteki çıktıda gösterildiği gibi, özel durum yalnızca sayıları yinelediğinizde ortaya çıkar ve numaralandırıcıyı aldığınızda gösterilmez.

public class IteratorWithoutLocalExample
{
   public static void Main()
   {
      IEnumerable<int> xs = OddSequence(50, 110);
      Console.WriteLine("Retrieved enumerator...");

      foreach (var x in xs)  // line 11
      {
         Console.Write($"{x} ");
      }
   }

   public static IEnumerable<int> OddSequence(int start, int end)
   {
      if (start < 0 || start > 99)
         throw new ArgumentOutOfRangeException(nameof(start), "start must be between 0 and 99.");
      if (end > 100)
         throw new ArgumentOutOfRangeException(nameof(end), "end must be less than or equal to 100.");
      if (start >= end)
         throw new ArgumentException("start must be less than end.");

      for (int i = start; i <= end; i++)
      {
         if (i % 2 == 1)
            yield return i;
      }
   }
}
// The example displays the output like this:
//
//    Retrieved enumerator...
//    Unhandled exception. System.ArgumentOutOfRangeException: end must be less than or equal to 100. (Parameter 'end')
//    at IteratorWithoutLocalExample.OddSequence(Int32 start, Int32 end)+MoveNext() in IteratorWithoutLocal.cs:line 22
//    at IteratorWithoutLocalExample.Main() in IteratorWithoutLocal.cs:line 11

Yineleyici mantığını yerel bir işleve koyarsanız, aşağıdaki örnekte gösterildiği gibi numaralandırıcıyı aldığınızda bağımsız değişken doğrulama özel durumları oluşturulur:

public class IteratorWithLocalExample
{
   public static void Main()
   {
      IEnumerable<int> xs = OddSequence(50, 110);  // line 8
      Console.WriteLine("Retrieved enumerator...");

      foreach (var x in xs)
      {
         Console.Write($"{x} ");
      }
   }

   public static IEnumerable<int> OddSequence(int start, int end)
   {
      if (start < 0 || start > 99)
         throw new ArgumentOutOfRangeException(nameof(start), "start must be between 0 and 99.");
      if (end > 100)
         throw new ArgumentOutOfRangeException(nameof(end), "end must be less than or equal to 100.");
      if (start >= end)
         throw new ArgumentException("start must be less than end.");

      return GetOddSequenceEnumerator();

      IEnumerable<int> GetOddSequenceEnumerator()
      {
         for (int i = start; i <= end; i++)
         {
            if (i % 2 == 1)
               yield return i;
         }
      }
   }
}
// The example displays the output like this:
//
//    Unhandled exception. System.ArgumentOutOfRangeException: end must be less than or equal to 100. (Parameter 'end')
//    at IteratorWithLocalExample.OddSequence(Int32 start, Int32 end) in IteratorWithLocal.cs:line 22
//    at IteratorWithLocalExample.Main() in IteratorWithLocal.cs:line 8

Yerel işlevler ile lambda ifadeleri karşılaştırması

İlk bakışta, yerel işlevler ve lambda ifadeleri benzerdir. Çoğu durumda lambda ifadelerini ve yerel işlevleri kullanma arasında seçim stil ve kişisel tercih konusudur. Ancak, farkında olmanız gereken birini veya diğerini kullanabileceğiniz gerçek farklılıklar vardır.

Şimdi faktöriyel algoritmanın yerel işlevi ile lambda ifadesi uygulamaları arasındaki farkları inceleyelim. Yerel işlev kullanan sürüm şu şekildedir:

public static int LocalFunctionFactorial(int n)
{
    return nthFactorial(n);

    int nthFactorial(int number) => number < 2 
        ? 1 
        : number * nthFactorial(number - 1);
}

Bu sürümde lambda ifadeleri kullanılır:

public static int LambdaFactorial(int n)
{
    Func<int, int> nthFactorial = default(Func<int, int>);

    nthFactorial = number => number < 2
        ? 1
        : number * nthFactorial(number - 1);

    return nthFactorial(n);
}

Adlandırma

Yerel işlevler açıkça yöntemler gibi adlandırılır. Lambda ifadeleri anonim yöntemlerdir ve genellikle delegate veya Action türlerinde bir Func türün değişkenlerine atanmalıdır. Yerel bir işlev bildirdiğinizde, işlem normal bir yöntem yazmaya benzer; bir dönüş türü ve işlev imzası bildirirsiniz.

İşlev imzaları ve lambda ifade türleri

Lambda ifadeleri, bağımsız değişkeni ve dönüş türlerini belirlemek için atandıkları değişkenin türüne Action/Func bağlıdır. Yerel işlevlerde, söz dizimi normal bir yöntem yazmaya çok benzer olduğundan, bağımsız değişken türleri ve dönüş türü zaten işlev bildiriminin bir parçasıdır.

Bazı lambda ifadeleri, derleyicinin lambda ifadesinin dönüş türünü ve parametre türlerini çıkarasına olanak tanıyan bir doğal türsahiptir.

Kesin atama

Lambda ifadeleri, çalışma zamanında bildirilen ve atanan nesnelerdir. Bir lambda ifadesinin kullanılabilmesi için kesinlikle atanması gerekir: atandığı Action/Func değişkeni bildirilmeli ve lambda ifadesi buna atanmış olmalıdır. LambdaFactorial Tanımlamadan önce lambda ifadesini nthFactorial bildirmesi ve başlatması gerektiğine dikkat edin. Bunun yapılmaması, atamadan önce başvuru nthFactorial için derleme süresi hatasına neden olur.

Yerel işlevler derleme zamanında tanımlanır. Değişkenlere atanmadığından, bunlar kapsamolduğu herhangi bir kod konumundan başvurulabilir; ilk örnekte, yerel işlevi deyiminden önce veya sonra bildirebilir ve derleyici hatalarını tetiklemeyebilirsiniz.

Bu farklılıklar özyinelemeli algoritmaların yerel işlevler kullanılarak oluşturulmasının daha kolay olduğu anlamına gelir. Kendisini çağıran bir yerel işlev bildirebilir ve tanımlayabilirsiniz. Lambda ifadelerinin, aynı lambda ifadesine başvuran bir gövdeye yeniden atanabilmesi için önce bildirilmeleri ve varsayılan bir değer almaları gerekir.

Temsilci olarak uygulama

Lambda ifadeleri, bildirildiğinde temsilcilere dönüştürülür. Yerel işlevler, geleneksel bir yöntem veya temsilci olarak yazılabilmesi için daha esnektir. Yerel işlevler yalnızca temsilci olarak kullanıldığında temsilcilere dönüştürülür.

Eğer yerel bir işlev bildirir ve sadece bir yöntemi çağırır gibi ona başvurursanız, bu işlev bir temsilciye dönüştürülmez.

Değişken yakalama

Kesin atama kuralları yerel işlev veya lambda ifadesi tarafından yakalanan tüm değişkenleri de etkiler. Derleyici, yerel işlevlerin kapsayan kapsamda yakalanan değişkenleri kesinlikle atamasını sağlayan statik analiz gerçekleştirebilir. Bu örneği ele alalım:

int M()
{
    int y;
    LocalFunction();
    return y;

    void LocalFunction() => y = 0;
}

Derleyici, çağrıldığında bunun kesinlikle atadığını LocalFunctiony belirleyebilir. Çünkü LocalFunction deyiminden return önce çağrılır, y kesinlikle deyiminde return atanır.

Bir yerel işlev kapsayan kapsamdaki değişkenleri yakaladığında, yerel işlev temsilci türleri gibi bir kapatma kullanılarak uygulanır.

Yığın ayırmaları

Kullanımlarına bağlı olarak, yerel işlevler lambda ifadeleri için her zaman gerekli olan yığın ayırmalarını önleyebilir. Yerel işlev hiçbir zaman temsilciye dönüştürülmezse ve yerel işlev tarafından yakalanan değişkenlerin hiçbiri temsilcilere dönüştürülen diğer lambda'lar veya yerel işlevler tarafından yakalanmazsa, derleyici yığın ayırmalarını önleyebilir.

Bu zaman uyumsuz örneği göz önünde bulundurun:

public async Task<string> PerformLongRunningWorkLambda(string address, int index, string name)
{
    if (string.IsNullOrWhiteSpace(address))
        throw new ArgumentException(message: "An address is required", paramName: nameof(address));
    if (index < 0)
        throw new ArgumentOutOfRangeException(paramName: nameof(index), message: "The index must be non-negative");
    if (string.IsNullOrWhiteSpace(name))
        throw new ArgumentException(message: "You must supply a name", paramName: nameof(name));

    Func<Task<string>> longRunningWorkImplementation = async () =>
    {
        var interimResult = await FirstWork(address);
        var secondResult = await SecondStep(index, name);
        return $"The results are {interimResult} and {secondResult}. Enjoy.";
    };

    return await longRunningWorkImplementation();
}

Bu lambda ifadesinin kapanışı address, indexve name değişkenlerini içerir. Yerel işlevler için, kapatıcıyı uygulayan nesnenin türü struct olabilir. Bu yapı türü, yerel işleve başvuruyla geçirilir. Uygulamadaki bu fark, ayırmada tasarruf sağlar.

Lambda ifadeleri için gereken örnekleme, zaman açısından kritik kod yollarında performans faktörü olabilecek ek bellek ayırmaları anlamına gelir. Yerel işlevler bu ek yüke neden olmaz.

Yerel işlevinizin temsilciye dönüştürülmeyeceğini ve bu işlev tarafından yakalanan değişkenlerin hiçbirinin temsilcilere dönüştürülen diğer lambda'lar veya yerel işlevler tarafından yakalanmadığını biliyorsanız, yerel işlevinizin yerel işlev olarak static bildirerek yığında ayrılmasını önlediğini garanti edebilirsiniz.

public async Task<string> PerformLongRunningWork(string address, int index, string name)
{
    if (string.IsNullOrWhiteSpace(address))
        throw new ArgumentException(message: "An address is required", paramName: nameof(address));
    if (index < 0)
        throw new ArgumentOutOfRangeException(paramName: nameof(index), message: "The index must be non-negative");
    if (string.IsNullOrWhiteSpace(name))
        throw new ArgumentException(message: "You must supply a name", paramName: nameof(name));

    return await longRunningWorkImplementation();

    async Task<string> longRunningWorkImplementation()
    {
        var interimResult = await FirstWork(address);
        var secondResult = await SecondStep(index, name);
        return $"The results are {interimResult} and {secondResult}. Enjoy.";
    }
}

Anahtar sözcüğün yield kullanımı

Bu örnekte gösterilmeyen son bir avantaj, yerel işlevlerin bir değer dizisi oluşturmak için söz dizimi kullanılarak yield return yineleyici olarak uygulanabilmesidir.

public IEnumerable<string> SequenceToLowercase(IEnumerable<string> input)
{
    if (!input.Any())
    {
        throw new ArgumentException("There are no items to convert to lowercase.");
    }
    
    return LowercaseIterator();
    
    IEnumerable<string> LowercaseIterator()
    {
        foreach (var output in input.Select(item => item.ToLower()))
        {
            yield return output;
        }
    }
}

lambda ifadelerinde yield return deyimine izin verilmez. Daha fazla bilgi için bkz. derleyici hatası CS1621.

Yerel işlevler lambda ifadelerine yedekli gibi görünse de, aslında farklı amaçlara hizmet eder ve farklı kullanımlara sahiptir. Yalnızca başka bir yöntemin bağlamından çağrılan bir işlev yazmak istediğinizde, yerel işlevler büyük/küçük harf için daha verimlidir.

C# dili belirtimi

Daha fazla bilgi için C# dil belirtiminin Yerel işlev bildirimleri bölümüne bakın.

Ayrıca bkz.

• Lambda yerine yerel işlevi kullanma (stil kuralı IDE0039)
• Yöntemler