ฟังก์ชั่นแบบอินไลน์ใน C #?

คุณจะทำอย่างไร "ฟังก์ชั่นแบบอินไลน์" ใน C #? ฉันไม่คิดว่าฉันเข้าใจแนวคิดนี้ พวกเขาชอบวิธีที่ไม่ระบุชื่อหรือไม่? เช่นเดียวกับฟังก์ชั่นแลมบ์ดา?

หมายเหตุ : คำตอบเกือบทั้งหมดเกี่ยวข้องกับความสามารถในการทำงานของอินไลน์เช่น "การปรับให้เหมาะสมด้วยตนเองหรือคอมไพเลอร์ที่แทนที่ไซต์การเรียกใช้ฟังก์ชันด้วยเนื้อความของผู้เรียก" หากคุณสนใจฟังก์ชั่นนิรนาม (aka lambda)โปรดดูคำตอบของ @ jalfหรือทุกคนที่ 'แลมบ์ดา' พูดถึงอะไร? .

ในที่สุดใน. NET 4.5, CLR อนุญาตให้หนึ่งคำแนะนำ / แนะนำ¹วิธีการอินไลน์โดยใช้MethodImplOptions.AggressiveInliningค่า นอกจากนี้ยังมีอยู่ในหีบของ Mono (มุ่งมั่นในวันนี้)

// 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 . ก่อนหน้านี้มีการใช้ "แรง" ที่นี่ เนื่องจากมีการโหวตไม่กี่ครั้งฉันจะพยายามอธิบายให้ชัดเจน ในความคิดเห็นและเอกสารThe method should be inlined if possible.โดยเฉพาะอย่างยิ่งเมื่อพิจารณาจากโมโน (ซึ่งเปิด) มีข้อ จำกัด ทางเทคนิคเฉพาะสำหรับการพิจารณาแบบอินไลน์หรือทั่วไปมากกว่าหนึ่ง (เช่นฟังก์ชั่นเสมือน) โดยรวมแล้วใช่นี่เป็นคำใบ้ของคอมไพเลอร์ แต่ฉันเดาว่าเป็นสิ่งที่ถูกถาม

วิธีการแบบอินไลน์เป็นเพียงการเพิ่มประสิทธิภาพของคอมไพเลอร์ที่รหัสของฟังก์ชั่นจะถูกรีดเข้าไปในผู้โทร

ไม่มีกลไกที่จะทำสิ่งนี้ใน C # และพวกมันจะถูกใช้อย่าง จำกัด ในภาษาที่พวกเขาได้รับการสนับสนุน - ถ้าคุณไม่รู้ว่าทำไมพวกเขาถึงต้องใช้ที่ไหนสักแห่งพวกเขาก็ไม่ควร

แก้ไข: เพื่อชี้แจงมีเหตุผลสำคัญสองประการที่จำเป็นต้องใช้อย่าง จำกัด :

1. มันง่ายที่จะสร้างไบนารีขนาดใหญ่โดยใช้อินไลน์ในกรณีที่ไม่จำเป็น
2. คอมไพเลอร์มีแนวโน้มที่จะรู้ดีกว่าที่คุณทำเมื่อมีบางสิ่งที่ควรจะถูก inline จากมุมมองประสิทธิภาพ

เป็นการดีที่สุดที่จะปล่อยให้สิ่งต่าง ๆ อยู่ตามลำพังและให้คอมไพเลอร์ทำงานตามปกติจากนั้นทำโปรไฟล์และหาว่าอินไลน์เป็นทางออกที่ดีที่สุดสำหรับคุณหรือไม่ แน่นอนว่ามีบางสิ่งที่เข้าท่า (ผู้ดำเนินการทางคณิตศาสตร์โดยเฉพาะ) แต่การให้คอมไพเลอร์จัดการมันเป็นวิธีปฏิบัติที่ดีที่สุด

อัปเดต:ตามคำตอบของ konrad.kruczynskiต่อไปนี้เป็นจริงสำหรับ. NET เวอร์ชั่นขึ้นไปและรวมถึง 4.0

คุณสามารถใช้คลาส MethodImplAttributeเพื่อป้องกันไม่ให้มีการinline ...

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

... แต่มีวิธีที่จะทำตรงข้ามและไม่มีการบังคับให้มีการ inlined

คุณกำลังผสมแนวคิดที่แยกกันสองอย่าง ฟังก์ชั่นอินไลน์เป็นคอมไพเลอร์ออปติไมซ์ที่ไม่มีผลกระทบต่อความหมาย ฟังก์ชั่นการทำงานเหมือนกันไม่ว่าจะเป็นแบบอินไลน์หรือไม่

ในทางกลับกันฟังก์ชั่นแลมบ์ดาเป็นแนวคิดเชิงความหมายอย่างแท้จริง ไม่มีข้อกำหนดว่าพวกเขาควรจะนำไปใช้หรือดำเนินการอย่างไรตราบเท่าที่พวกเขาทำตามพฤติกรรมที่กำหนดไว้ในข้อมูลจำเพาะภาษา พวกเขาสามารถอินไลน์ถ้าคอมไพเลอร์ JIT รู้สึกเหมือนมันหรือไม่ถ้ามันไม่ได้

ไม่มีคำหลักแบบอินไลน์ใน C # เนื่องจากเป็นการเพิ่มประสิทธิภาพที่สามารถทิ้งไว้กับคอมไพเลอร์โดยเฉพาะในภาษา JIT คอมไพเลอร์ JIT มีการเข้าถึงสถิติรันไทม์ซึ่งช่วยให้สามารถตัดสินใจว่าจะอินไลน์ได้อย่างมีประสิทธิภาพมากขึ้นกว่าที่คุณสามารถทำได้เมื่อเขียนโค้ด ฟังก์ชั่นจะมีการแทรกหากคอมไพเลอร์ตัดสินใจและไม่มีอะไรที่คุณสามารถทำได้ด้วยวิธีใดวิธีหนึ่ง :)

คุณหมายถึงฟังก์ชั่นแบบอินไลน์ในความหมาย C ++ หรือไม่ เนื้อหาของฟังก์ชั่นปกติใดที่จะถูกคัดลอกแบบอินไลน์โดยอัตโนมัติใน callsite? ผลสุดท้ายคือการที่ไม่มีการเรียกใช้ฟังก์ชันเกิดขึ้นจริงเมื่อเรียกใช้ฟังก์ชัน

ตัวอย่าง:

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

ถ้าเป็นเช่นนั้นไม่จะไม่มี C # ที่เทียบเท่ากับสิ่งนี้

หรือคุณหมายถึงฟังก์ชั่นที่ถูกประกาศในฟังก์ชั่นอื่นหรือไม่? ถ้าใช่ดังนั้น C # จะสนับสนุนสิ่งนี้ผ่านวิธีการไม่ระบุชื่อหรือการแสดงออกแลมบ์ดา

ตัวอย่าง:

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

โคดี้พูดถูก แต่ฉันต้องการให้ตัวอย่างของฟังก์ชันอินไลน์

สมมติว่าคุณมีรหัสนี้:

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;
}

คอมไพเลอร์ Just-In-Time เพิ่มประสิทธิภาพสามารถเลือกที่จะเปลี่ยนรหัสเพื่อหลีกเลี่ยงการวางซ้ำ ๆ เรียกร้องให้ OutputItem () บนสแต็คเพื่อว่ามันจะเป็นเช่นถ้าคุณได้เขียนรหัสเช่นนี้แทน:

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;
}

ในกรณีนี้เราจะบอกว่าฟังก์ชั่น OutputItem () นั้นถูก inline โปรดทราบว่าอาจทำสิ่งนี้แม้ว่าจะเรียก OutputItem () จากที่อื่นเช่นกัน

แก้ไขเพื่อแสดงสถานการณ์มีแนวโน้มที่จะถูกแทรก

ใช่ความแตกต่างเพียงอย่างเดียวคือความจริงที่ว่ามันคืนค่า

การทำให้เข้าใจง่าย (ไม่ใช้นิพจน์):

List<T>.ForEach ทำการกระทำโดยไม่คาดหวังผลตอบแทน

ดังนั้นAction<T>ตัวแทนจะพอเพียง .. พูดว่า:

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

เหมือนกับการพูดว่า:

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

ความแตกต่างคือประเภท param และ decleration ของตัวแทนได้รับการอนุมานจากการใช้งานและไม่จำเป็นต้องใช้เครื่องมือจัดฟันในวิธีการแบบอินไลน์อย่างง่าย

อยู่ที่ไหน

List<T>.Where รับฟังก์ชั่นโดยคาดหวังผลลัพธ์

ดังนั้นFunction<T, bool>จะคาดหวัง:

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

ซึ่งเหมือนกับ:

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

นอกจากนี้คุณยังสามารถประกาศวิธีการเหล่านี้แบบอินไลน์และกำหนดให้กับตัวแปร IE:

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

myAction();

หรือ

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

string myString = myFunction(someObject);

ฉันหวังว่านี่จะช่วยได้.

มีบางครั้งที่ฉันต้องการบังคับให้โค้ดอยู่ในแนว

ตัวอย่างเช่นถ้าฉันมีกิจวัตรที่ซับซ้อนซึ่งมีการตัดสินใจจำนวนมากภายในบล็อกที่มีการวนซ้ำสูงและการตัดสินใจเหล่านั้นส่งผลให้มีการกระทำที่คล้ายกัน แต่แตกต่างกันเล็กน้อย ลองพิจารณาตัวอย่างเช่นตัวเรียงลำดับที่ซับซ้อน (ไม่ใช่ฐานข้อมูลขับเคลื่อน) ซึ่งตัวเรียงลำดับ algorythm เรียงลำดับองค์ประกอบตามจำนวนของเกณฑ์ที่ไม่เกี่ยวข้องที่แตกต่างกันเช่นหนึ่งอาจทำถ้าพวกเขาเรียงคำตามไวยากรณ์และความหมายของภาษาที่รวดเร็ว ระบบการรับรู้ ฉันมักจะเขียนฟังก์ชันผู้ช่วยเพื่อจัดการการกระทำเหล่านั้นเพื่อรักษาความสามารถในการอ่านและโมดุลของรหัสต้นฉบับ

ฉันรู้ว่าฟังก์ชั่นผู้ช่วยเหล่านั้นควรอยู่ในแนวเดียวกันเพราะนั่นเป็นวิธีที่รหัสจะถูกเขียนหากมนุษย์ไม่เคยเข้าใจ แน่นอนฉันต้องการรับประกันในกรณีนี้ว่าไม่มีฟังก์ชั่นการโทรโอเวอร์เฮด

คำแถลง "สิ่งที่ดีที่สุดที่จะทิ้งสิ่งเหล่านี้ไว้ตามลำพังและให้คอมไพเลอร์ทำงานได้ .. " (Cody Brocious) เป็นทับทิมสมบูรณ์ ฉันเขียนโปรแกรมเกมที่มีประสิทธิภาพสูงเป็นเวลา 20 ปีและฉันยังไม่ได้เจอคอมไพเลอร์ที่ 'ฉลาดพอที่จะรู้ว่าควรใช้โค้ดใดในฟังก์ชัน (ฟังก์ชั่น) หรือไม่ มันจะมีประโยชน์ที่จะมีคำสั่ง "inline" ใน c # ความจริงก็คือคอมไพเลอร์ไม่ได้มีข้อมูลทั้งหมดที่จำเป็นในการกำหนดฟังก์ชั่นที่ควรจะมีการ inline เสมอหรือไม่ไม่มีคำแนะนำ "inline" แน่นอนว่าถ้าฟังก์ชั่นนั้นมีขนาดเล็ก (accessor) มันอาจถูก inline อัตโนมัติ แต่ถ้ามันเป็นโค้ดไม่กี่บรรทัดล่ะ? เปล่าเลย, คอมไพเลอร์ไม่มีทางรู้, คุณไม่สามารถปล่อยให้มันถึงคอมไพเลอร์สำหรับรหัสที่ได้รับการปรับปรุง (เกินกว่าอัลกอริทึม)

ฉันรู้ว่าคำถามนี้เป็นเรื่องเกี่ยวกับ C # อย่างไรก็ตามคุณสามารถเขียนฟังก์ชั่นอินไลน์ใน. NET ด้วย F # ดู: การใช้ `inline 'ใน F #

ไม่ไม่มีโครงสร้างดังกล่าวใน C # แต่คอมไพเลอร์. NET JIT สามารถตัดสินใจที่จะทำการเรียกฟังก์ชั่นแบบอินไลน์ในเวลา JIT แต่จริง ๆ แล้วฉันไม่รู้ว่ามันทำการปรับให้เหมาะสมเช่นนั้นจริงหรือไม่
(ฉันคิดว่าควร :-))

ในกรณีที่ชุดประกอบของคุณจะเป็น ngen-ed คุณอาจต้องการดูที่ TargetedPatchingOptOut สิ่งนี้จะช่วยให้ ngen ตัดสินใจว่าจะใช้วิธีการแบบอินไลน์หรือไม่ การอ้างอิง MSDN

มันยังคงเป็นเพียงคำใบ้เพื่อเพิ่มประสิทธิภาพ แต่ไม่ใช่คำสั่งที่จำเป็น

นิพจน์แลมบ์ดาเป็นฟังก์ชั่นอินไลน์! ฉันคิดว่า C # ไม่มีคุณสมบัติพิเศษเช่นอินไลน์หรืออะไรแบบนั้น!

C # ไม่สนับสนุนวิธีการแบบอินไลน์ (หรือฟังก์ชั่น) ในวิธีที่ภาษาแบบไดนามิกเช่นหลามทำ อย่างไรก็ตามวิธีการที่ไม่ระบุชื่อและ lambdas สามารถใช้เพื่อวัตถุประสงค์ที่คล้ายกันรวมถึงเมื่อคุณจำเป็นต้องเข้าถึงตัวแปรในวิธีการที่มีเช่นในตัวอย่างด้านล่าง

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

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