0Pricing
C# Academy · บทเรียน

ฟังก์ชันภายในเทียบกับแลมบ์ดา

เลือกใช้ระหว่างฟังก์ชันภายในกับแลมบ์ดา

ฟังก์ชันภายในเทียบกับแลมบ์ดา เป็นบทเรียน C# Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C# Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C# Academy มีบทเรียนทั้งหมด 4 บทเรียน

ฟังก์ชันภายในกับแลมบ์ดา

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

สองวิธีในการเขียนฟังก์ชันช่วยเหลือ

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

using System;

public class Program
{
    public static void Main()
    {
        int SquareFn(int n) => n * n;       // local function
        Func<int, int> squareLambda = n => n * n; // lambda

        Console.WriteLine(SquareFn(4));
        Console.WriteLine(squareLambda(4));
    }
}

ฟังก์ชันภายในรองรับการเรียกซ้ำได้ง่าย

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

using System;

public class Program
{
    public static void Main()
    {
        // Clean recursion with a local function
        int Factorial(int n) => n <= 1 ? 1 : n * Factorial(n - 1);
        Console.WriteLine(Factorial(5));
    }
}

ฟังก์ชันภายในสามารถเป็นชนิดข้อมูลทั่วไปได้

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

using System;

public class Program
{
    public static void Main()
    {
        T First<T>(T[] items) => items[0]; // generic local function

        Console.WriteLine(First(new[] { 9, 8, 7 }));
        Console.WriteLine(First(new[] { "a", "b" }));
    }
}

ประสิทธิภาพ: หลีกเลี่ยงการจัดสรรดีลีเกต

แลมบ์ดาที่กำหนดให้กับดีลีเกตอาจจัดสรรออบเจ็กต์ดีลีเกต และหากมีการจับตัวแปรก็อาจจัดสรรคลอเชอร์ด้วย การเรียกใช้ฟังก์ชันภายในโดยตรงจะหลีกเลี่ยงทั้งสองอย่าง ซึ่งมีความสำคัญในลูปที่ถูกเรียกบ่อย

using System;

public class Program
{
    public static void Main()
    {
        // Direct call, no delegate or closure allocation
        static int Add(int a, int b) => a + b;

        int total = 0;
        for (int i = 0; i < 5; i++) total = Add(total, i);
        Console.WriteLine(total);
    }
}

พารามิเตอร์ out และ ref

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

using System;

public class Program
{
    public static void Main()
    {
        bool TryGetFirstDigit(string s, out int digit)
        {
            digit = 0;
            foreach (var c in s)
                if (char.IsDigit(c)) { digit = c - '0'; return true; }
            return false;
        }

        if (TryGetFirstDigit("abc4", out int d))
            Console.WriteLine(d);
    }
}

แลมบ์ดาโดดเด่นเมื่อใช้เป็นอาร์กิวเมนต์แบบแทรกโดยตรง

เมื่อคุณต้องส่งพฤติกรรมการทำงานเข้าไปในเมธอดโดยตรง เช่น LINQ Where หรือ Select แลมบ์ดาเป็นตัวเลือกที่กระชับและอ่านเข้าใจง่ายที่สุด

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3, 4, 5, 6 };
        var evens = nums.Where(n => n % 2 == 0).Select(n => n * 10);
        Console.WriteLine(string.Join(", ", evens));
    }
}

การจับค่าทำงานได้ทั้งสองแบบ

ทั้งสองรูปแบบสามารถจับตัวแปรจากบริบทภายนอกได้ ความแตกต่างส่วนใหญ่อยู่ที่ไวยากรณ์และต้นทุนการจัดสรรหน่วยความจำ ไม่ใช่ความสามารถในการจับค่า

using System;

public class Program
{
    public static void Main()
    {
        int bonus = 10;
        int WithBonusFn(int n) => n + bonus;     // captures
        Func<int, int> withBonusLambda = n => n + bonus; // captures

        Console.WriteLine(WithBonusFn(5));
        Console.WriteLine(withBonusLambda(5));
    }
}

การกำหนดค่าแน่นอนและลำดับ

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

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Triple(4)); // allowed before declaration

        int Triple(int n) => n * 3;
    }
}

การเลือกระหว่างสองรูปแบบ

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

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        static bool IsPrime(int n)
        {
            if (n < 2) return false;
            for (int i = 2; i * i <= n; i++)
                if (n % i == 0) return false;
            return true;
        }

        var primes = Enumerable.Range(2, 20).Where(IsPrime);
        Console.WriteLine(string.Join(", ", primes));
    }
}

ลองทำด้วยตัวเอง

ใช้ฟังก์ชันภายในแบบเรียกตัวเองสำหรับตรรกะหลัก และใช้แลมบ์ดาสำหรับการแปลงข้อมูลด้วย LINQ แบบแทรกโดยตรง เพื่อให้แต่ละโครงสร้างทำงานที่เหมาะสมที่สุด

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        // Local function: recursive, named, reusable
        static int DigitCount(int n) => Math.Abs(n) < 10 ? 1 : 1 + DigitCount(n / 10);

        var nums = new List<int> { 5, 42, 1000, 7, 88 };
        // Lambda: concise inline projection
        var report = nums.Select(n => n + " has " + DigitCount(n) + " digits");
        foreach (var line in report) Console.WriteLine(line);
    }
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว

เปรียบเทียบโครงสร้างทั้งสองแบบ

สรุปทบทวน

ฟังก์ชันภายในและแลมบ์ดามีความสามารถทับซ้อนกัน แต่แตกต่างกันในประเด็นสำคัญ

  • ฟังก์ชันภายในสามารถเรียกตัวเอง ใช้กับชนิดข้อมูลทั่วไป และใช้ out/ref ได้
  • เมื่อเรียกใช้โดยตรง ฟังก์ชันเหล่านี้ไม่ต้องจัดสรรตัวแทนหรือส่วนปิดล้อม
  • แลมบ์ดากระชับที่สุดเมื่อใช้เป็นอาร์กิวเมนต์แบบแทรกโดยตรงให้กับเมธอด เช่น LINQ
  • เลือกตามจุดประสงค์: ตัวช่วยที่มีชื่อและเรียกใช้ซ้ำได้ หรือตัวพฤติกรรมสั้น ๆ ที่แทรกโดยตรง

คำถามที่พบบ่อย

บทเรียน “ฟังก์ชันภายในเทียบกับแลมบ์ดา” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ฟังก์ชันภายในเทียบกับแลมบ์ดา” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C# Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C# Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชันภายในเทียบกับแลมบ์ดา”

เลือกใช้ระหว่างฟังก์ชันภายในกับแลมบ์ดา คุณปฏิบัติ C# Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C# Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C# Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “ฟังก์ชันภายในเทียบกับแลมบ์ดา” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C# Academy นี้ได้ไหม

ได้ บทเรียน C# Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การประกาศฟังก์ชันภายใน
  2. โคลเชอร์และตัวแปรที่ถูกจับค่า
  3. ฟังก์ชันภายในแบบสแตติก
  4. ฟังก์ชันภายในเทียบกับแลมบ์ดา
← กลับไปที่ C# Academy