การประกาศฟังก์ชันภายใน
กำหนดฟังก์ชันช่วยเหลือภายในเมธอด
การประกาศฟังก์ชันภายใน เป็นบทเรียน C# Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C# Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C# Academy มีบทเรียนทั้งหมด 4 บทเรียน
ฟังก์ชันภายในคืออะไร
ฟังก์ชันภายในคือเมธอดที่ประกาศอยู่ภายในเมธอดอื่น ฟังก์ชันนี้มองเห็นได้เฉพาะภายในสมาชิกที่ครอบอยู่ จึงทำให้ตรรกะช่วยเหลืออยู่ใกล้จุดที่ใช้งานและไม่ทำให้ส่วนที่เปิดเผยของคลาสมีเมธอดเพิ่มขึ้น
การประกาศฟังก์ชันภายใน
เขียนฟังก์ชันภายในเหมือนเมธอดทั่วไป โดยซ้อนอยู่ภายในบล็อก คุณสามารถเรียกใช้ฟังก์ชันนี้ก่อนหรือหลังการประกาศได้ภายในขอบเขตเดียวกัน
using System;
public class Program
{
public static void Main()
{
int Square(int n) => n * n;
Console.WriteLine(Square(4));
Console.WriteLine(Square(7));
}
}ฟังก์ชันภายในแบบมีบล็อก
ฟังก์ชันภายในสามารถมีบล็อกคำสั่งเต็มรูปแบบที่ประกอบด้วยคำสั่งหลายคำสั่ง ลูป และตัวแปรภายในของตนเองได้เช่นเดียวกับเมธอดทั่วไป
using System;
public class Program
{
public static void Main()
{
int Factorial(int n)
{
int result = 1;
for (int i = 2; i <= n; i++) result *= i;
return result;
}
Console.WriteLine(Factorial(5));
}
}การปรับปรุงความอ่านง่าย
ฟังก์ชันภายในช่วยให้คุณตั้งชื่อส่วนหนึ่งของตรรกะได้โดยไม่ทำให้คลาสมีเมธอดส่วนตัวที่ใช้โดยเมธอดเดียวเท่านั้นมากเกินไป วิธีนี้ช่วยให้โค้ดที่เกี่ยวข้องอยู่รวมกัน
using System;
public class Program
{
public static void Main()
{
string Format(string label, int value) => label + ": " + value;
Console.WriteLine(Format("Score", 90));
Console.WriteLine(Format("Level", 3));
}
}การเรียกซ้ำด้วยฟังก์ชันภายใน
ฟังก์ชันภายในสามารถเรียกใช้ตัวเองได้ ทำให้เขียนการเรียกซ้ำได้ง่ายตรงจุดที่ต้องการ
using System;
public class Program
{
public static void Main()
{
int Fib(int n) => n < 2 ? n : Fib(n - 1) + Fib(n - 2);
for (int i = 0; i < 7; i++)
Console.Write(Fib(i) + " ");
Console.WriteLine();
}
}ฟังก์ชันภายในสามารถประกาศหลังการใช้งานได้
ต่างจากตัวแปรภายใน ฟังก์ชันภายในสามารถถูกอ้างอิงก่อนตำแหน่งที่ประกาศภายในเมธอดได้ คอมไพเลอร์จะประมวลผลขอบเขตที่ครอบอยู่ทั้งหมด
using System;
public class Program
{
public static void Main()
{
Console.WriteLine(Greet("Ada")); // used before declared
string Greet(string name) => "Hello, " + name;
}
}พารามิเตอร์และชนิดผลลัพธ์
ฟังก์ชันภายในรองรับทุกอย่างที่เมธอดทั่วไปทำได้ ได้แก่ พารามิเตอร์หลายตัว ค่าที่ส่งกลับ พารามิเตอร์ ref และ out รวมถึงชนิดข้อมูลทั่วไป
using System;
public class Program
{
public static void Main()
{
bool TryHalve(int n, out int half)
{
half = n / 2;
return n % 2 == 0;
}
if (TryHalve(10, out int result))
Console.WriteLine("half is " + result);
}
}ฟังก์ชันภายในแบบชนิดข้อมูลทั่วไป
ฟังก์ชันภายในสามารถเป็นชนิดข้อมูลทั่วไปและรับพารามิเตอร์ชนิดข้อมูลของตนเองได้อย่างอิสระจากเมธอดที่ครอบอยู่
using System;
public class Program
{
public static void Main()
{
T Echo<T>(T value)
{
Console.WriteLine("echoing " + value);
return value;
}
int n = Echo(42);
string s = Echo("hi");
Console.WriteLine(n + " " + s);
}
}การซ้อนฟังก์ชันภายใน
ฟังก์ชันภายในสามารถมีฟังก์ชันภายในซ้อนอยู่ภายในได้เช่นกัน ฟังก์ชันชั้นในจะมองเห็นได้เฉพาะภายในฟังก์ชันแม่ ทำให้สร้างชั้นของฟังก์ชันช่วยเหลือที่มีขอบเขตชัดเจนได้
using System;
public class Program
{
public static void Main()
{
int Compute(int x)
{
int Double(int n) => n * 2;
int AddOne(int n) => n + 1;
return Double(AddOne(x));
}
Console.WriteLine(Compute(5));
}
}ฟังก์ชันภายในสำหรับตรวจสอบอาร์กิวเมนต์
รูปแบบที่พบได้ทั่วไปคือ ตรวจสอบอาร์กิวเมนต์ทันที แล้วจึงเลื่อนการทำงานจริงไปไว้ในฟังก์ชันภายใน วิธีนี้มีประโยชน์เป็นพิเศษกับตัววนซ้ำ เพราะทำให้การตรวจสอบทำงานทันที
using System;
using System.Collections.Generic;
public class Program
{
static IEnumerable<int> Range(int start, int count)
{
if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
return Iterate();
IEnumerable<int> Iterate()
{
for (int i = 0; i < count; i++) yield return start + i;
}
}
public static void Main()
{
foreach (var n in Range(10, 3)) Console.WriteLine(n);
}
}ควรใช้ฟังก์ชันภายในเมื่อใด
เลือกใช้ฟังก์ชันภายในเมื่อฟังก์ชันช่วยเหลือถูกใช้โดยเมธอดเดียวเท่านั้น ได้ประโยชน์จากการมีชื่อที่สื่อความหมาย หรือจำเป็นต้องเข้าถึงสถานะภายในของเมธอด วิธีนี้ช่วยให้คลาสสะอาดและค้นหาตรรกะได้ง่าย
using System;
public class Program
{
public static void Main()
{
int total = 0;
void Add(int n) => total += n; // helper tied to this method
Add(3); Add(4); Add(5);
Console.WriteLine(total);
}
}ตรวจสอบอย่างรวดเร็ว
ทบทวนว่าฟังก์ชันภายในคืออะไร
สรุปทบทวน
ฟังก์ชันภายในคือฟังก์ชันช่วยเหลือที่มีชื่อและซ้อนอยู่ภายในเมธอด
- มองเห็นได้เฉพาะภายในสมาชิกที่ครอบอยู่
- รองรับพารามิเตอร์ ค่าที่ส่งกลับ
out/refชนิดข้อมูลทั่วไป และการเรียกซ้ำ - สามารถถูกอ้างอิงก่อนการประกาศได้
- เหมาะอย่างยิ่งกับฟังก์ชันช่วยเหลือที่ใช้ครั้งเดียวและการตรวจสอบอาร์กิวเมนต์ทันทีในตัววนซ้ำ
คำถามที่พบบ่อย
บทเรียน “การประกาศฟังก์ชันภายใน” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การประกาศฟังก์ชันภายใน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C# Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C# Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การประกาศฟังก์ชันภายใน”
กำหนดฟังก์ชันช่วยเหลือภายในเมธอด คุณปฏิบัติ C# Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C# Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน C# Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “การประกาศฟังก์ชันภายใน” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน C# Academy นี้ได้ไหม
ได้ บทเรียน C# Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การประกาศฟังก์ชันภายใน
- โคลเชอร์และตัวแปรที่ถูกจับค่า
- ฟังก์ชันภายในแบบสแตติก
- ฟังก์ชันภายในเทียบกับแลมบ์ดา