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

ฟังก์ชันภายในแบบสแตติก

ป้องกันการจับค่าเพื่อความชัดเจนและประสิทธิภาพ

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

ฟังก์ชันภายในแบบ static

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

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

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

using System;

public class Program
{
    public static void Main()
    {
        static int Square(int n) => n * n; // captures nothing

        Console.WriteLine(Square(6));
    }
}

ไม่อนุญาตให้จับตัวแปร

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

using System;

public class Program
{
    public static void Main()
    {
        int factor = 3;
        // factor must be passed in, not captured
        static int Scale(int n, int f) => n * f;

        Console.WriteLine(Scale(5, factor));
    }
}

หลีกเลี่ยงการจัดสรรหน่วยความจำแฝง

ฟังก์ชันภายในที่ไม่เป็น static และจับตัวแปรไว้อาจจัดสรรออบเจ็กต์คลอเชอร์แฝง ฟังก์ชันภายในแบบ static จะไม่จับตัวแปรใด ๆ จึงหลีกเลี่ยงการจัดสรรนั้นได้ทั้งหมด

using System;

public class Program
{
    public static void Main()
    {
        // Pure helper, no closure object created
        static bool IsEven(int n) => n % 2 == 0;

        for (int i = 0; i < 5; i++)
            Console.WriteLine(i + ": " + IsEven(i));
    }
}

เจตนาที่อธิบายได้ด้วยตัวเอง

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

using System;

public class Program
{
    public static void Main()
    {
        static int Clamp(int value, int lo, int hi)
            => value < lo ? lo : value > hi ? hi : value;

        Console.WriteLine(Clamp(15, 0, 10));
        Console.WriteLine(Clamp(-3, 0, 10));
    }
}

คอมไพเลอร์บังคับไม่ให้จับตัวแปร

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

using System;

public class Program
{
    public static void Main()
    {
        int seed = 7;
        // Correct: seed is passed explicitly, not captured
        static int Mix(int x, int s) => x * 31 + s;

        Console.WriteLine(Mix(2, seed));
    }
}

ตัวแปรภายในแบบ static กับการเรียกซ้ำ

ฟังก์ชันภายในแบบ static ยังคงรองรับการเรียกซ้ำ เพราะการเรียกใช้ตัวเองไม่เหมือนกับการจับตัวแปร

using System;

public class Program
{
    public static void Main()
    {
        static int Power(int baseN, int exp)
            => exp == 0 ? 1 : baseN * Power(baseN, exp - 1);

        Console.WriteLine(Power(2, 10));
    }
}

การใช้ร่วมกับพารามิเตอร์ out

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

using System;

public class Program
{
    public static void Main()
    {
        static bool TryParsePositive(string s, out int value)
        {
            value = 0;
            return int.TryParse(s, out value) && value > 0;
        }

        if (TryParsePositive("42", out int n))
            Console.WriteLine("got " + n);
        Console.WriteLine(TryParsePositive("-1", out _));
    }
}

การส่งตัวแปรภายในแบบ static เป็นดีลีเกต

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

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

public class Program
{
    public static void Main()
    {
        static bool IsBig(int n) => n > 100;

        var nums = new List<int> { 50, 150, 200, 10 };
        Console.WriteLine(nums.Count(IsBig));
    }
}

ควรเลือกใช้ static เมื่อใด

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

using System;

public class Program
{
    public static void Main()
    {
        static string Describe(int score)
        {
            if (score >= 90) return "A";
            if (score >= 80) return "B";
            return "C";
        }

        Console.WriteLine(Describe(95));
        Console.WriteLine(Describe(82));
    }
}

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

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

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

public class Program
{
    public static void Main()
    {
        static bool IsLeapYear(int year)
            => (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;

        var years = new List<int> { 1900, 2000, 2004, 2021, 2024 };
        Console.WriteLine(string.Join(", ", years.Where(IsLeapYear)));
    }
}

ตรวจสอบอย่างรวดเร็ว

ทบทวนว่า static เพิ่มคุณสมบัติใดให้ฟังก์ชันภายใน

สรุปทบทวน

ฟังก์ชันภายในแบบ static จะไม่จับตัวแปรใด ๆ

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

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

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

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

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

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

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

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

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

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

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

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

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

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