C # satır içi işlevleri?

C # "satır içi işlevleri" nasıl yaparsınız? Kavramı anladığımı sanmıyorum. Anonim yöntemler gibi mi? Lambda fonksiyonları gibi mi?

Not : Cevaplar neredeyse tamamen fonksiyonların inline edilmesiyle ilgilidir , yani "bir fonksiyon çağrı sitesini callee gövdesiyle değiştiren bir manuel veya derleyici optimizasyonu". Anonim (aka lambda) işlevleriyle ilgileniyorsanız , @ jalf'ın cevabına bakın veya herkesin konuştuğu bu 'Lambda' nedir? .

Son olarak .NET 4.5'te CLR, bir değeri kullanarak satır içi ¹ yöntem önerebilir MethodImplOptions.AggressiveInlining. Aynı zamanda Mono'nun bagajında ​​da mevcuttur (bugün taahhüt edilmiştir).

// The full attribute usage is in mscorlib.dll,
// so should not need to include extra references
using System.Runtime.CompilerServices; 

...

[MethodImpl(MethodImplOptions.AggressiveInlining)]
void MyMethod(...)

1 . Daha önce burada "kuvvet" kullanılmıştır. Birkaç downvotes olduğundan, terimi açıklığa kavuşturmaya çalışacağım. Yorumlarda ve dokümantasyonda olduğu gibi, The method should be inlined if possible.Özellikle Mono (açık olan) dikkate alındığında, satır içi veya daha genel olanı (sanal fonksiyonlar gibi) dikkate alan mono-spesifik teknik sınırlamalar vardır. Genel olarak, evet, bu derleyici bir ipucu, ama sanırım ne istedi.

Satır içi yöntemler, bir işlevin kodunun arayanın içine yuvarlandığı bir derleyici optimizasyonudur.

Bunu C # ile yapacak bir mekanizma yoktur ve desteklendikleri dillerde az miktarda kullanılmalıdırlar - neden bir yerde kullanılmaları gerektiğini bilmiyorsanız, olmamalıdırlar.

Düzenleme: Açıklığa kavuşturmak için, az miktarda kullanılması gereken iki önemli neden vardır:

1. Gerekli olmadığı durumlarda satır içi kullanarak büyük ikili dosyalar oluşturmak kolaydır
2. Derleyici, performans açısından bakıldığında bir şeyin çizgisel olması gerektiğinden daha iyi bilme eğilimindedir

Bir şeyleri yalnız bırakmak ve derleyicinin işini yapmasına izin vermek en iyisidir, ardından satır içi sizin için en iyi çözüm olup olmadığını profil ve hesaplayın. Tabii ki, bazı şeyler sadece çizgisel olmak için mantıklıdır (özellikle matematiksel operatörler), ancak derleyicinin bunu işlemesine izin vermek genellikle en iyi uygulamadır.

Güncelleme: Başına konrad.kruczynski cevabı , şu .NET sürümleri kadar ve 4.0 dahil olmak için de geçerlidir.

Bir yöntemin satır içine alınmasını önlemek için MethodImplAttribute sınıfını kullanabilirsiniz ...

[MethodImpl(MethodImplOptions.NoInlining)]
void SomeMethod()
{
    // ...
}

... ama tam tersini yapmanın ve satır içi olmasını zorlamanın bir yolu yoktur .

İki ayrı kavramı karıştırıyorsunuz. İşlev satır içi, semantiğe etkisi olmayan bir derleyici optimizasyonudur. Bir işlev satır içi olsun ya da olmasın aynı şekilde davranır.

Öte yandan, lambda fonksiyonları tamamen semantik bir kavramdır. Dil spesifikasyonunda belirtilen davranışa uydukları sürece nasıl uygulanmaları veya yürütülmeleri gerektiği konusunda bir gereklilik yoktur. JIT derleyicisi böyle hissediyorsa satır içine alınabilir ya da değil.

C # 'da satır içi anahtar kelime yoktur, çünkü genellikle derleyiciye, özellikle de JIT' dillerinde bırakılabilen bir optimizasyondur. JIT derleyicisi, kod yazarken neye göre daha verimli satır içi olacağına karar vermesini sağlayan çalışma zamanı istatistiklerine erişebilir. Derleyici karar verirse bir işlev satır içine alınır ve bu konuda her iki şekilde de yapabileceğiniz hiçbir şey yoktur. :)

C ++ anlamında satır içi işlevler mi demek istediniz? Normal bir işlevin içeriği otomatik olarak satır yerine çağrı sitesine kopyalanır? Sonuç olarak, bir işlev çağrıldığında hiçbir işlev çağrısı gerçekleşmez.

Misal:

inline int Add(int left, int right) { return left + right; }

Eğer öyleyse hayır, buna C # eşdeğeri yoktur.

Veya başka bir işlev içinde bildirilen işlevler mi demek istediniz? Öyleyse evet, C # bunu anonim yöntemler veya lambda ifadeleri ile destekler.

Misal:

static void Example() {
  Func<int,int,int> add = (x,y) => x + y;
  var result = add(4,6);  // 10
}

Cody'nin hakkı var, ama satır içi fonksiyonun ne olduğuna bir örnek vermek istiyorum.

Diyelim ki bu koda sahipsiniz:

private void OutputItem(string x)
{
    Console.WriteLine(x);

    //maybe encapsulate additional logic to decide 
    // whether to also write the message to Trace or a log file
}

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{  // let's pretend IEnumerable<T>.ToList() doesn't exist for the moment
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);
        OutputItem(y);
    }
    return result;
}

Derleyici Just-In-Time iyileştirici artık şöyle bir kod yazmış gibi olurdu ki, yığının üzerine OutputItem () çağrısı yerleştirerek tekrar tekrar önlemek için kodu değiştirmek tercih edebilirsiniz:

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);

        // full OutputItem() implementation is placed here
        Console.WriteLine(y);   
    }

    return result;
}

Bu durumda, OutputItem () işlevinin satıriçi olduğunu söyleyebiliriz. OutputItem () başka yerlerden de çağrılsa bile bunu yapabileceğini unutmayın.

Sıralı olma olasılığı daha yüksek bir senaryo gösterecek şekilde düzenlendi.

Evet Kesinlikle tek fark, bir değer döndürmesidir.

Sadeleştirme (ifadeleri kullanmamak):

List<T>.ForEach Bir işlem yapar, bir dönüş sonucu beklemez.

Yani bir Action<T>delege yeterli olur ..

List<T>.ForEach(param => Console.WriteLine(param));

demekle aynıdır:

List<T>.ForEach(delegate(T param) { Console.WriteLine(param); });

aradaki fark, param tipi ve delege deklerasyonunun kullanımla çıkarılması ve parantezlerin basit bir satır içi yöntemde gerekli olmamasıdır.

Buna karşılık

List<T>.Where Sonuç bekleyen bir işlev alır.

Yani bir Function<T, bool>beklenen:

List<T>.Where(param => param.Value == SomeExpectedComparison);

ki aynı:

List<T>.Where(delegate(T param) { return param.Value == SomeExpectedComparison; });

Ayrıca bu yöntemleri satır içinde bildirebilir ve IE değişkenlerine atayabilirsiniz:

Action myAction = () => Console.WriteLine("I'm doing something Nifty!");

myAction();

veya

Function<object, string> myFunction = theObject => theObject.ToString();

string myString = myFunction(someObject);

Umarım bu yardımcı olur.

Kodun sıralı olmasını zorlamak istediğim durumlar var.

Örneğin, oldukça yinelemeli bir blok içinde çok sayıda kararın verildiği ve bu kararların benzer ancak biraz farklı eylemlerin gerçekleştirilmesine neden olan karmaşık bir rutinim varsa. Örneğin, sıralama algoritmasının, öğeleri hızlı bir dil için gramatik ve anlamsal ölçütlere göre sıralıyorlarsa yapabileceği gibi bir dizi farklı ilişkisiz kritere göre sıraladığı karmaşık (DB tabanlı olmayan) bir sıralama karşılaştırıcısını düşünün tanıma sistemi. Kaynak kodun okunabilirliğini ve modülerliğini korumak için bu eylemleri gerçekleştirmek için yardımcı işlevler yazma eğilimindeyim.

Bu yardımcı fonksiyonların sıralı olması gerektiğini biliyorum, çünkü kod asla bir insan tarafından anlaşılmasaydı yazılacaktı. Kesinlikle bu durumda ek yükü çağıran bir fonksiyon olmadığından emin olmak isterim.

"Bunları yalnız bırakmak ve derleyicinin işi yapmasına izin vermek en iyisi" ifadesi (Cody Brocious) tam anlamıyla rubish. 20 yıldır yüksek performanslı oyun kodunu programlıyorum ve henüz hangi kodun satır içi (fonksiyonlar) olması gerektiğini bilmek için 'yeterince akıllı' bir derleyiciye rastlamadım. Bu c # bir "satır içi" ifadesi olması yararlı olacaktır, gerçek şu ki derleyici sadece "satır içi" ipucu olmadan hangi işlev her zaman satır içi ya da değil olması gerektiğini belirlemek için gereken tüm bilgilere sahip değildir. Fonksiyon küçük (erişimci) olduğundan emin olun, otomatik olarak satır içine alınabilir, ancak birkaç satırlık kod varsa? Nonesense, derleyici bilmenin hiçbir yolu yoktur, sadece optimize edilmiş kod (algoritmaların ötesinde) için derleyiciye bırakamazsınız.

Bu sorunun C # ile ilgili olduğunu biliyorum. Ancak, F # ile .NET'te satır içi işlevler yazabilirsiniz. bkz: F # 'da `` satır içi' 'kullanımı

Hayır, C # 'da böyle bir yapı yoktur, ancak .NET JIT derleyicisi JIT zamanında satır içi işlev çağrıları yapmaya karar verebilir. Ama aslında gerçekten böyle optimizasyonlar yapıp yapmadığını bilmiyorum.
(Sanırım :-))

Derlemelerinizin ngen-edileceği durumda, TargetedPatchingOptOut'a bakmak isteyebilirsiniz. Bu, ngen'in satır içi yöntemleri belirleyip belirlemeyeceğine karar verecektir. MSDN başvurusu

Yine de, zorunlu kılan bir komut değil, optimize etmek sadece beyan edici bir ipucudur.

Lambda ifadeleri satır içi işlevlerdir! Bence, C # inline veya bunun gibi bir ekstra özelliğe sahip değil!

C #, python gibi dinamik dillerin yaptığı gibi satır içi yöntemleri (veya işlevleri) desteklemez. Bununla birlikte, anonim yöntemler ve lambdalar, aşağıdaki örnekte olduğu gibi, içeren yöntemde bir değişkene ne zaman erişmeniz gerektiği de dahil olmak üzere benzer amaçlar için kullanılabilir.

static void Main(string[] args)
{
    int a = 1;

    Action inline = () => a++;
    inline();
    //here a = 2
}