ฟังก์ชันภายในเทียบกับแลมบ์ดา
เลือกใช้ระหว่างฟังก์ชันภายในกับแลมบ์ดา
ฟังก์ชันภายในเทียบกับแลมบ์ดา เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การประกาศฟังก์ชันภายใน
- โคลเชอร์และตัวแปรที่ถูกจับค่า
- ฟังก์ชันภายในแบบสแตติก
- ฟังก์ชันภายในเทียบกับแลมบ์ดา