c# - StackOverflow प्लेटफ़ॉर्म डेवलपर्स प्रदर्शन के लिए स्थिर तरीकों का उपयोग क्यों करते हैं?




performance static (2)

मैं StackExchange प्रौद्योगिकी (उदाहरण के लिए, highavailability.com पर SO प्रदर्शन के बारे में इस आलेख) के बारे में पढ़ रहा हूं, और यह देखा है कि वे बेहतर प्रदर्शन के लिए स्थिर तरीके के भारी उपयोग का उल्लेख करते हैं।

स्थिर तरीके क्यों बेहतर प्रदर्शन करते हैं? मुझे लगता होगा कि कचरा संग्रह की लागत में कमी इसके साथ कुछ है (चूंकि स्थैतिक तरीकों के लिए कोई उदाहरण नहीं है); हालांकि, क्या कुछ और है?


सादगी और बेहतर प्रदर्शन के लिए स्थिर कक्षाओं और विधियों का भारी उपयोग

जहां वास्तविक निष्पादन लाभ ठोस व्यवसाय व्यवस्था के लिए ठोस सिस्टम सेटअप और ठोस मेट्रिक्स से संबंधित हैं, जहां static वर्गों और विधियों का उपयोग करने की सरलता, जहां यह संभव है, से प्राप्त होता है:

1) स्थिर विधि में "निष्पादन केवल" प्रवाह का स्पष्ट अभिव्यक्ति

2) आसान इकाई परीक्षण, क्योंकि आप केवल निष्पादन विरूपण साक्ष्य (स्थिर कार्य) के साथ काम कर रहे हैं

3) राज्य और निष्पादन अलग और अलग मूल्य हैं, इसलिए कोई "छिपा राज्य" के मुद्दे नहीं हैं (स्थिर गैर अपरिवर्तनीय वार्स आमतौर पर एक खराब डिजाइन का संकेत), या उनमें से छोटी राशि अन्यथा

कुल मिलाकर, कोड को प्रबंधित करना , परीक्षण करना और संभवतः समझना आसान है


स्थिर तरीके क्यों बेहतर प्रदर्शन करते हैं?

मुझे नहीं लगता कि वे करते हैं शायद जीसी समय में कुछ लाभ है, अगर डेटा स्थिर तरीके से पारित किया जाता है और उसमें से लौटे तो यह स्टैक पर छोड़ देता है। इस मामले में यह जीसी द्वारा ट्रैक नहीं है

मैं एक प्रोग्राम चलाया और मेरे 3 प्रयासों के लिए अलग-अलग परिणाम मिला, दो बार स्थिर विधि थोड़ा तेज थी, 1 बार (नीचे दिखाया गया) उदाहरण विधि तेजी से थी उचित विचलन श्रेणी के सभी डेटा तो मेरा निष्कर्ष: यदि जीसी को छोड़कर कोई स्पष्ट अंतर नहीं है

t1 = 8.0055 ms (instance)
t2 = 8.0119 ms (static)

यहां एक त्वरित परीक्षण कार्यक्रम है

public class Program
{
    const int innerMax = 100;
    const int outerMax = 1000;

    public static void Main()
    {
        var t1 = new TimeSpan();
        var t2 = new TimeSpan();

        var program = new Program();

        for (int i = 0; i < outerMax; i++)
            t1 = program.InstanceAction();

        for (int i = 0; i < outerMax; i++)
            t2 = StaticAction();

        Console.WriteLine("t1 = {0} ms (instance)", t1.TotalMilliseconds);
        Console.WriteLine("t2 = {0} ms (static)", t2.TotalMilliseconds);
        Console.ReadLine();
    }

    private TimeSpan InstanceAction()
    {
        return Time(() => {
            var sw = new SpinWait();
            for (int i = 0; i < max; i++)
                sw.SpinOnce();
        });
    }

    private static TimeSpan StaticAction()
    {
        return Time(() => {
            var sw = new SpinWait();
            for (int i = 0; i < innerMax; i++)
                sw.SpinOnce();
        });
    }

    private static TimeSpan Time(Action action)
    {
        Stopwatch stopwatch = Stopwatch.StartNew();
        action();
        stopwatch.Stop();
        return stopwatch.Elapsed;
    }
}




static