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

การประกาศฟังก์ชันภายใน

กำหนดฟังก์ชันช่วยเหลือภายในเมธอด

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

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

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