Yerel işlev vs Lambda C # 7.0

C # 7.0 yeni uygulamalara bakıyorum ve yerel işlevleri uyguladıklarını ilginç buluyorum, ancak bir lambda ifadesi yerine yerel bir işlev tercih edilecek bir senaryo hayal edemiyorum ve ikisi arasındaki fark nedir.

Lamdaların anonymousbu arada fonksiyonlar olduğunu anlıyorum , ancak yerel fonksiyonlar değil, ancak yerel fonksiyonun lambda ifadelerine göre avantajları olduğu gerçek bir dünya senaryosu bulamıyorum

Herhangi bir örnek çok takdir edilecektir. Teşekkürler.

Bu, yerel işlevlerin ilk kez tartışıldığı C # Tasarım Toplantısı Notlarında Mads Torgersen tarafından açıklandı :

Bir yardımcı fonksiyon istiyorsunuz. Bunu yalnızca tek bir işlevden kullanıyorsunuz ve büyük olasılıkla bu işlevin kapsamındaki değişkenleri ve tür parametrelerini kullanıyor. Öte yandan, bir lambda'nın aksine, birinci sınıf bir nesne olarak buna ihtiyacınız yoktur, bu nedenle ona bir delege türü vermek ve gerçek bir delege nesnesi tahsis etmek önemli değildir. Ayrıca yinelemeli veya genel olmasını veya yineleyici olarak uygulanmasını isteyebilirsiniz.

Üzerinde biraz daha genişlemek için avantajları:

1. Verim.

   Bir lambda oluştururken, bu durumda gereksiz bir tahsis olan bir temsilci oluşturulmalıdır. Yerel işlevler gerçekten sadece işlevlerdir, delege gerek yoktur.

   Ayrıca, yerel işlevler yerel değişkenleri yakalamada daha verimlidir: lambdalar genellikle değişkenleri bir sınıfa alırken, yerel işlevler refyeniden ayırmayı önleyen bir yapı (kullanarak geçirilir ) kullanabilir .

   Bu aynı zamanda yerel işlevlerin çağrılmasının daha ucuz olduğu ve satır içine alınabileceği anlamına gelir ve muhtemelen performansı daha da artırır.

2. Yerel işlevler özyinelemeli olabilir.

   Lambdas da özyinelemeli olabilir, ancak önce nullbir delege değişkenine ve sonra lambda'ya atadığınız garip kod gerektirir . Yerel işlevler doğal olarak özyinelemeli olabilir (karşılıklı özyinelemeli dahil).

3. Yerel işlevler genel olabilir.

   Lambdalar genel olamaz, çünkü somut tipte bir değişkene atanmaları gerekir (bu tip dış kapsamdan genel değişkenler kullanabilir, ancak bu aynı şey değildir).

4. Yerel işlevler yineleyici olarak uygulanabilir.

   Lambdas, -returning işlevini uygulamak için yield return(ve yield break) anahtar sözcüğünü kullanamaz IEnumerable<T>. Yerel fonksiyonlar yapabilir.

5. Yerel işlevler daha iyi görünür.

   Bu yukarıdaki alıntıda belirtilmemiş ve sadece kişisel önyargım olabilir, ancak normal işlev sözdiziminin bir delege değişkenine lambda atamaktan daha iyi olduğunu düşünüyorum. Yerel işlevler de daha özlüdür.

   Karşılaştırmak:

   int add(int x, int y) => x + y;
   Func<int, int, int> add = (x, y) => x + y;

Svick'in harika cevabına ek olarak , yerel fonksiyonlara bir avantaj daha vardır: İfadeden
sonra bile fonksiyonun herhangi bir yerinde tanımlanabilirler return.

public double DoMath(double a, double b)
{
    var resultA = f(a);
    var resultB = f(b);
    return resultA + resultB;

    double f(double x) => 5 * x + 3;
}

Yerel işlevi nasıl test edeceğinizi merak ediyorsanız , bunu yapmak için işlevselliğe sahip olduğu için JustMock'u kontrol etmelisiniz . Test edilecek basit bir sınıf örneği:

public class Foo // the class under test
{ 
    public int GetResult() 
    { 
        return 100 + GetLocal(); 
        int GetLocal () 
        { 
            return 42; 
        } 
    } 
}

Ve test şu şekilde görünüyor:

[TestClass] 
public class MockLocalFunctions 
{ 
    [TestMethod] 
    public void BasicUsage() 
    { 
        //Arrange 
        var foo = Mock.Create<Foo>(Behavior.CallOriginal); 
        Mock.Local.Function.Arrange<int>(foo, "GetResult", "GetLocal").DoNothing(); 

        //Act 
        var result = foo. GetResult(); 

        //Assert 
        Assert.AreEqual(100, result); 
    } 
} 

İşte JustMock belgelerine bir link .

Yasal Uyarı. JustMock'tan sorumlu geliştiricilerden biriyim .

Uzun çalışma yöntemleri ile uğraşırken özel olarak çöp toplama basıncını önlemek için satır içi işlevler kullanıyorum. Diyelim ki, belirli bir sembol için 2 yıl veya piyasa verileri almak istersiniz. Ayrıca, gerekirse çok sayıda işlevsellik ve iş mantığı paketlenebilir.

birinin yaptığı şey, sunucuya bir soket bağlantısı açmak ve bir olayı bir olaya bağlayan veriler üzerinde döngü yapmaktır. Bir sınıf tasarlandığı gibi düşünülebilir, sadece bir tanesi gerçekten sadece bir işlevsellik pili için çalışan bir yerde yardımcı yöntemler yazmıyor. Aşağıda bu nasıl görünebilir bazı örnek, ben değişkenleri kullanıyorum ve "yardımcı" yöntemleri sonunda aşağıda olduğunu unutmayın. Sonunda güzelce olay işleyicileri kaldırmak, benim Exchange sınıf harici / enjekte olurdu ben herhangi bir bekleyen olay işleyicisi kayıtlı olmaz

void List<HistoricalData> RequestData(Ticker ticker, TimeSpan timeout)
{
    var socket= new Exchange(ticker);
    bool done=false;
    socket.OnData += _onData;
    socket.OnDone += _onDone;
    var request= NextRequestNr();
    var result = new List<HistoricalData>();
    var start= DateTime.Now;
    socket.RequestHistoricalData(requestId:request:days:1);
    try
    {
      while(!done)
      {   //stop when take to long….
        if((DateTime.Now-start)>timeout)
           break;
      }
      return result;

    }finally
    {
        socket.OnData-=_onData;
        socket.OnDone-= _onDone;
    }


   void _OnData(object sender, HistoricalData data)
   {
       _result.Add(data);
   }
   void _onDone(object sender, EndEventArgs args)
   {
      if(args.ReqId==request )
         done=true;
   } 
}

Aşağıda belirtildiği gibi avantajları görebilirsiniz, burada örnek bir uygulama görebilirsiniz. Umarım faydaları açıklamaya yardımcı olur.