ข้อดีของการใช้เมธอดแบบสแตติกส่วนตัว

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

ตัวอย่าง:

foreach (XmlElement element in xmlDoc.DocumentElement.SelectNodes("sample"))
{
    string first = GetInnerXml(element, ".//first");
    string second = GetInnerXml(element, ".//second");
    string third = GetInnerXml(element, ".//third");
}

...

private static string GetInnerXml(XmlElement element, string nodeName)
{
    return GetInnerXml(element, nodeName, null);
}

private static string GetInnerXml(XmlElement element, string nodeName, string defaultValue)
{
    XmlNode node = element.SelectSingleNode(nodeName);
    return node == null ? defaultValue : node.InnerXml;
}

มีประโยชน์ใด ๆ ในการประกาศวิธี GetInnerXml () เป็นแบบคงที่หรือไม่ ไม่มีความเห็นโปรดตอบฉันมีความคิดเห็น

จากหน้ากฎ FxCopในสิ่งนี้:

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

เมื่อฉันเขียนชั้นเรียนวิธีการส่วนใหญ่แบ่งออกเป็นสองประเภท:

• วิธีการที่ใช้ / เปลี่ยนสถานะของอินสแตนซ์ปัจจุบัน
• วิธีใช้ตัวช่วยที่ไม่ได้ใช้ / เปลี่ยนสถานะของวัตถุปัจจุบัน แต่ช่วยฉันคำนวณค่าที่ฉันต้องการที่อื่น

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

ใช้ตัวอย่างนี้:

ห้องสมุดสาธารณะ
{
    หนังสือส่วนตัวแบบคงที่ findBook (รายการ <Book> หนังสือ, ชื่อสตริง)
    {
        // code ไปที่นี่
    }
}

หากสถานะของห้องสมุดผิดพลาดและฉันพยายามหาสาเหตุว่าทำไมฉันจึงสามารถแยก FindBook ออกมาเป็นผู้ร้ายได้

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

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

src: MSDN - http://msdn.microsoft.com/en-us/library/79b3xss3(v=vs.110).aspx

ใช่คอมไพเลอร์ไม่จำเป็นต้องผ่านthisตัวชี้โดยนัยไปยังstaticเมธอด แม้ว่าคุณจะไม่ได้ใช้มันในวิธีการอินสแตนซ์ของคุณก็ยังคงถูกส่งผ่าน

มันจะเร็วขึ้นเล็กน้อยเนื่องจากไม่มีการส่งพารามิเตอร์นี้ (แม้ว่าค่าใช้จ่ายในการเรียกใช้วิธีการอาจจะมากกว่าการบันทึกนี้)

ฉันจะบอกเหตุผลที่ดีที่สุดที่ฉันคิดว่าสำหรับวิธีการคงที่ส่วนตัวคือมันหมายความว่าคุณไม่สามารถเปลี่ยนวัตถุโดยไม่ตั้งใจ (เนื่องจากไม่มีตัวชี้นี้)

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

ฉันชอบวิธีการส่วนตัวทุกอย่างมากที่จะคงที่เว้นแต่พวกเขาไม่สามารถ ฉันชอบสิ่งต่อไปนี้มาก:

public class MyClass
{
    private readonly MyDependency _dependency;

    public MyClass(MyDependency dependency)
    {
        _dependency = dependency;
    }

    public int CalculateHardStuff()
    {
        var intermediate = StepOne(_dependency);
        return StepTwo(intermediate);
    }

    private static int StepOne(MyDependency dependency)
    {
        return dependency.GetFirst3Primes().Sum();
    }

    private static int StepTwo(int intermediate)
    {
        return (intermediate + 5)/4;
    }
}

public class MyDependency
{
    public IEnumerable<int> GetFirst3Primes()
    {
        yield return 2;
        yield return 3;
        yield return 5;
    }
}

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

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

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

ดังที่ได้กล่าวไปแล้วมีข้อดีหลายประการสำหรับวิธีการคงที่ อย่างไรก็ตาม; โปรดทราบว่าพวกเขาจะมีชีวิตอยู่บนกองเพื่อชีวิตของแอปพลิเคชัน ฉันเพิ่งใช้เวลาหนึ่งวันในการติดตามการรั่วไหลของหน่วยความจำในบริการ Windows ... การรั่วไหลเกิดจากวิธีการคงที่ส่วนตัวภายในชั้นเรียนที่ใช้ IDisposable และถูกเรียกอย่างสม่ำเสมอจากคำสั่งที่ใช้ แต่ละครั้งที่คลาสนี้ถูกสร้างขึ้นหน่วยความจำถูกสงวนไว้บนฮีพสำหรับเมธอดแบบคงที่ภายในคลาส แต่น่าเสียดายที่เมื่อคลาสนั้นถูกกำจัดหน่วยความจำสำหรับเมธอดแบบสแตติกจะไม่ถูกปล่อยออกมา สิ่งนี้ทำให้ footprint หน่วยความจำของบริการนี้ใช้หน่วยความจำที่มีอยู่ของเซิร์ฟเวอร์ภายในสองสามวันด้วยผลลัพธ์ที่สามารถคาดเดาได้