क्या यूनिट परीक्षण के लिए सार्वभौमिक रूप से "बुराई" है और यदि ऐसा है तो रेस्पर इसे क्यों सुझाता है? [बन्द है]

85

मैंने पाया है कि यूनिट टेस्ट (मॉक / स्टब) निर्भरता के केवल 3 तरीके हैं जो C # .NET में स्थिर हैं:

यह देखते हुए कि इनमें से दो मुक्त नहीं हैं और किसी ने 1.0 रिलीज नहीं किया है, स्थैतिक सामान का मजाक उड़ाना बहुत आसान नहीं है।

क्या यह स्थिर तरीके और ऐसी "बुराई" (इकाई परीक्षण की भावना में) बनाता है? और यदि ऐसा है, तो पुनर्विक्रेता मुझे ऐसा कुछ क्यों बनाना चाहते हैं जो स्थिर, स्थिर हो सकता है? (मान लिया गया है कि फेरबदल भी "बुराई" नहीं है।)

स्पष्टीकरण: मैं उस परिदृश्य के बारे में बात कर रहा हूँ जब आप एक विधि का परीक्षण करना चाहते हैं और वह विधि किसी भिन्न इकाई / वर्ग में एक स्थिर विधि कहलाती है। इकाई परीक्षण की अधिकांश परिभाषाओं के अनुसार, यदि आप परीक्षण विधि के तहत दूसरी इकाई / कक्षा में स्थैतिक विधि को कॉल करते हैं तो आप इकाई परीक्षण नहीं कर रहे हैं, आप एकीकरण परीक्षण कर रहे हैं । (उपयोगी, लेकिन एक इकाई परीक्षण नहीं।)

c# unit-testing static-methods mocking

— Vaccano
स्रोत

3

TheLQ: आप कर सकते हैं। मेरा मानना है कि वह स्थैतिक तरीकों का परीक्षण करने में सक्षम नहीं होने के बारे में बात कर रहा है क्योंकि ज्यादातर समय यह स्थिर चर को छूता है। इस प्रकार परीक्षण के बाद और बीच में राज्य बदलना।

26

व्यक्तिगत रूप से मुझे लगता है कि आप बहुत दूर "यूनिट" की परिभाषा ले रहे हैं। "यूनिट" होना चाहिए "सबसे छोटी इकाई जो अलगाव में परीक्षण करने के लिए समझ में आता है"। यह एक विधि हो सकती है, यह इससे अधिक भी हो सकती है। यदि स्टैटिक विधि की कोई स्थिति नहीं है और अच्छी तरह से परीक्षण किया गया है, तो दूसरी इकाई परीक्षण कॉल होने पर यह (IMO) एक मुद्दा नहीं है।

— mlk

10

"व्यक्तिगत रूप से मुझे लगता है कि आप" यूनिट "की परिभाषा बहुत दूर ले जा रहे हैं।" नहीं, इसका सिर्फ इतना है कि वह मानक उपयोग के साथ जा रहा है और आप अपनी खुद की परिभाषा बना रहे हैं।

7

"पुनर्जीवन मुझे ऐसा कुछ क्यों बनाना चाहता है जो स्थिर, स्थिर हो सकता है?" Resharper नहीं चाहता कि आप कुछ भी करें। यह केवल आप जानते हैं कि संशोधन संभव है और कर रहा है हो सकता है एक कोड विश्लेषण पीओवी से वांछनीय। Resharper अपने स्वयं के निर्णय के लिए एक प्रतिस्थापन नहीं है!

— एडम नायलर

4

@ acidzombie24। नियमित तरीके स्टेटिक स्टेट को भी संशोधित कर सकते हैं, इसलिए वे स्टैटिक तरीकों की तरह "खराब" होंगे। तथ्य यह है कि वे एक छोटे जीवन चक्र के साथ राज्य को संशोधित कर सकते हैं और उन्हें अभी तक और अधिक खतरनाक बना देता है। (मैं स्थिर तरीकों के पक्ष में नहीं हूं, लेकिन राज्य संशोधन के बारे में बात नियमित तरीकों के लिए भी एक झटका है, और भी बहुत कुछ)

— mike30

105

यहाँ अन्य उत्तरों को देखते हुए, मुझे लगता है कि स्थिर तरीकों के बीच कुछ भ्रम हो सकता है जो स्थिर स्थिति रखते हैं या साइड-इफ़ेक्ट का कारण बनते हैं (जो मुझे बहुत बुरा लगता है), और स्थैतिक विधियाँ जो केवल एक मान लौटाती हैं।

स्टेटिक तरीके जो बिना किसी राज्य को पकड़ते हैं और बिना किसी साइड इफेक्ट के आसानी से परीक्षण योग्य हो सकते हैं। वास्तव में, मैं ऐसे तरीकों को "गरीब-आदमी का" कार्यात्मक प्रोग्रामिंग का रूप मानता हूं; आप विधि को एक वस्तु या मूल्य सौंपते हैं, और यह एक वस्तु या मूल्य लौटाता है। और कुछ नहीं। मैं यह नहीं देखता कि इस तरह की विधियाँ इकाई परीक्षण को नकारात्मक रूप से कैसे प्रभावित करेंगी।

— रॉबर्ट हार्वे
स्रोत

44

स्थैतिक विधि इकाई परीक्षण योग्य है, लेकिन उन विधियों के बारे में क्या है जो स्थैतिक विधि को कहते हैं? यदि कॉल करने वाले दूसरे वर्ग में हैं, तो उनके पास एक निर्भरता है जिसे एक यूनिट टेस्ट करने के लिए डिकॉय करने की आवश्यकता है।

— 15

22

@Vaccano: लेकिन अगर आप स्टेटिक मेथड लिखते हैं, जो स्टेट को होल्ड नहीं करता है और इसका कोई साइड इफेक्ट नहीं है, तो वे वैसे भी कम या ज्यादा कार्यात्मक रूप से स्टब के बराबर हैं।

— राबर्ट हार्वे

20

सरल शायद। लेकिन अधिक जटिल लोग अपवादों को फेंकना शुरू कर सकते हैं और आउटपुट हो सकते हैं जो अपेक्षित नहीं हैं (और स्थिर विधि के लिए इकाई परीक्षण में पकड़ा जाना चाहिए, स्थैतिक विधि के कॉलर के लिए इकाई परीक्षण में नहीं), या कम से कम जो मैं कर रहा हूं मेरे द्वारा पढ़े गए साहित्य पर विश्वास करने के लिए नेतृत्व किया गया है।

— 19

20

@Vaccano: एक स्थिर विधि जिसमें आउटपुट या यादृच्छिक अपवाद हैं, के दुष्प्रभाव हैं।

— तिखन जेल्विस

10

@TikhonJelvis रॉबर्ट आउटपुट के बारे में बात कर रहे थे; और "यादृच्छिक" अपवादों का एक साइड इफेक्ट नहीं होना चाहिए, वे मूल रूप से आउटपुट का एक रूप हैं। मुद्दा यह है कि जब भी आप किसी विधि का परीक्षण करते हैं, जो स्थैतिक विधि को बुलाती है, तो आप उस विधि और उसके संभावित आउटपुट के सभी क्रमों को लपेट रहे हैं, और अलगाव में आपकी विधि का परीक्षण नहीं कर सकते।

— निकोल

26

आप स्थैतिक डेटा और स्थिर तरीकों को भ्रमित करने लगते हैं । Resharper, अगर मुझे सही याद है, privateतो क्लास स्टैटिक के भीतर तरीके बनाने की सिफारिश करता है अगर उन्हें ऐसा बनाया जा सकता है - मेरा मानना है कि इससे एक छोटे प्रदर्शन का लाभ मिलता है। यह "स्थिर" हो सकता है कि कुछ भी बनाने की सिफारिश नहीं करता है !

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

public static long Square(int x)
{
    return x * x;
}

तब यह प्रमुख रूप से परीक्षण योग्य है और इसका कोई दुष्प्रभाव नहीं है। आप बस यह देख लें कि जब आप पास होते हैं, तो कहते हैं, 20 आपको 400 मिलते हैं। कोई बात नहीं।

— दान डिपलो
स्रोत

4

जब आपके पास कोई दूसरा वर्ग होता है जो इस स्थैतिक विधि को कॉल करता है तो क्या होता है? इस मामले में सरल लगता है, लेकिन यह एक निर्भरता है जिसे ऊपर सूचीबद्ध तीन उपकरणों में से एक को छोड़कर अलग नहीं किया जा सकता है। यदि आप इसे अलग नहीं करते हैं, तो आप "इकाई परीक्षण" नहीं कर रहे हैं, तो आप "एकीकरण परीक्षण" कर रहे हैं (क्योंकि आप परीक्षण कर रहे हैं कि आपकी विभिन्न इकाइयाँ कितनी अच्छी तरह एक साथ "एकीकृत" कर रही हैं।

— 15

3

कुछ नहीं हुआ। क्यों होगा? .NET फ्रेमवर्क स्थिर विधियों से भरा है। क्या आप कह रहे हैं कि आप इनका इस्तेमाल किसी भी तरीके से नहीं कर सकते, जिसे आप यूनिट टेस्ट के लिए करना चाहते हैं?

— दान डिपलो

3

ठीक है, यदि आपका कोड .NET फ्रेमवर्क के उत्पादन स्तर / गुणवत्ता पर है तो सुनिश्चित करें, आगे बढ़ें। लेकिन इकाई परीक्षण का पूरा बिंदु अलगाव में, परीक्षण इकाई है। यदि आप अन्य इकाइयों में विधियां भी कह रहे हैं (जैसे वे स्थिर या अन्यथा हैं) तो अब आप अपनी इकाई और उसकी निर्भरता का परीक्षण कर रहे हैं। मैं यह नहीं कह रहा हूं कि यह एक उपयोगी परीक्षण नहीं है, लेकिन अधिकांश परिभाषाओं द्वारा "इकाई परीक्षण" नहीं है। (क्योंकि अब आप अपने यूनिट-अंडर-टेस्ट और उस इकाई का परीक्षण कर रहे हैं जिसमें स्थिर विधि है)।

— टीका

10

संभवतः आपने (या अन्य) पहले से ही स्थैतिक विधि का परीक्षण किया है और यह दिखाया है कि इसके चारों ओर बहुत अधिक लिखने से पहले यह (कम से कम उम्मीद के अनुसार) काम करता है। यदि आपके द्वारा परीक्षण किए जाने वाले भाग में कुछ टूट जाता है, तो यह वह जगह है जहां आपको पहले देखना चाहिए, उस सामान में नहीं जिसे आपने पहले ही परीक्षण किया है।

— 19

6

@Vaccano तो Microsoft .NET फ्रेमवर्क का परीक्षण कैसे करते हैं, फिर, एह? अन्य वर्गों में फ्रेमवर्क संदर्भ में कई कक्षाएं (जैसे System.Math) स्थिर कारखाने विधियों की प्रचुरता का उल्लेख नहीं करने के लिए (जैसे ) प्लस आप किसी भी विस्तार विधियों आदि का उपयोग नहीं कर पाएंगे। तथ्य यह है, इस तरह के सरल कार्य हैं आधुनिक भाषाओं के लिए मौलिक। आप इन्हें अलग-थलग कर सकते हैं (क्योंकि ये आम तौर पर नियतात्मक होते हैं) और फिर बिना किसी चिंता के अपनी कक्षाओं में इनका उपयोग करें। यह एक समस्या नहीं है!

— दान डिप्लो

18

अगर यहां असली सवाल यह है कि "मैं इस कोड का परीक्षण कैसे करूं?":

public class MyClass
{
   public void MethodToTest()
   {
       //... do something
       MyStaticClass.StaticMethod();
       //...more
   }
}

फिर, बस कोड को रिफलेक्टर करें और हमेशा की तरह स्टैटिक क्लास को कॉल करें:

public class MyClass
{
   private readonly IExecutor _externalExecutor;
   public MyClass(_IExecutor executor)
   {
       _exeternalExecutor = executor;
   }

   public void MethodToTest()
   {
       //... do something
       _exetrnalExecutor.DoWork();
       //...more
   }
}

public class MyStaticClassExecutor : IExecutor
{
    public void DoWork()
    {
        MyStaticClass.StaticMethod();
    }
}

— धूप
स्रोत

9

सौभाग्य से हम भी कोड पठनीयता और KISS के बारे में सवाल तो भी पर :) है

— gbjbaanb

क्या एक प्रतिनिधि आसान नहीं होगा और वही काम करेगा?

— जे.के.

@ जेक हो सकता है, लेकिन इसके लिए आईओसी कंटेनर का उपयोग करना कठिन है।

— सनी

15

स्टैटिक्स अनिवार्य रूप से बुराई नहीं हैं, लेकिन वे आपके विकल्पों को सीमित कर सकते हैं जब यह नकली / नकली / स्टब्स के साथ इकाई-परीक्षण की बात आती है।

मॉकिंग करने के दो सामान्य तरीके हैं।

पहले वाले (पारंपरिक - राइनोमॉक्स, Moq, NMock2 द्वारा लागू; मैनुअल मोक्स और स्टब्स इस शिविर में भी हैं) टेस्ट सीम और निर्भरता इंजेक्शन पर निर्भर करता है। मान लीजिए कि आप कुछ स्थैतिक कोड का इकाई परीक्षण कर रहे हैं और इसमें निर्भरताएँ हैं। इस तरह से डिज़ाइन किए गए कोड में अक्सर ऐसा होता है कि स्टेटिक्स अपनी निर्भरता बनाते हैं, निर्भरता व्युत्क्रम को उलटते हैं । आपको जल्द ही पता चलता है कि आप परीक्षण के तहत कोड में नकली इंटरफेस को इंजेक्ट नहीं कर सकते हैं जो इस तरह से डिज़ाइन किया गया है।

दूसरा एक (कुछ भी - टाइपमॉक, जस्टमॉक और मोल्स द्वारा लागू किया गया) .NET के प्रोफाइलिंग एपीआई पर निर्भर करता है । यह आपके CIL के किसी भी निर्देश को रोक सकता है और आपके कोड के एक ठगी को नकली के साथ बदल सकता है। यह इस शिविर में टाइपमॉक और अन्य उत्पादों को कुछ भी मॉक करने की अनुमति देता है: स्टैटिक्स, सीलबंद कक्षाएं, निजी तरीके - परीक्षण योग्य नहीं बनाई गई चीजें।

दो स्कूलों के बीच विचार-विमर्श चल रहा है। एक कहता है, परीक्षण के लिए SOLID सिद्धांतों और डिजाइन का पालन करें (जिसमें अक्सर स्टैटिक्स पर आसान होना शामिल है)। दूसरा कहता है, टाइपमॉक खरीदें और चिंता न करें।

— azheglov
स्रोत

14

इसे देखें: "स्टेटिक मेथड्स टू डेथ टू टेस्टेबिलिटी" । तर्क का संक्षिप्त सारांश:

इकाई परीक्षण के लिए आपको अपने कोड का एक छोटा टुकड़ा लेने की जरूरत है, इसकी निर्भरता को फिर से परखें और इसे अलगाव में परीक्षण करें। यह स्थैतिक तरीकों से कठिन है, न केवल उस स्थिति में जब वे वैश्विक स्थिति तक पहुंच प्राप्त करते हैं, लेकिन भले ही वे अन्य स्थिर तरीकों को कहते हैं।

— राफेल डाउगर्ड
स्रोत

32

मैं अपने स्थिर तरीकों में वैश्विक स्थिति नहीं रखता या दुष्प्रभाव नहीं डालता, इसलिए यह तर्क मुझे अप्रासंगिक लगता है। आपके द्वारा जोड़ा गया लेख एक फिसलन ढलान तर्क बनाता है जिसका कोई आधार नहीं है यदि स्थिर तरीके सरल प्रक्रियात्मक कोड तक सीमित हैं, "जेनेरिक" तरीके (जैसे गणित फ़ंक्शन) में अभिनय करते हैं।

— रॉबर्ट हार्वे

4

@ रोबर्ट हार्वे - आप एक ऐसी विधि का परीक्षण कैसे करते हैं जो किसी अन्य वर्ग से एक स्थिर विधि का उपयोग करती है (अर्थात इसमें एक स्थिर विधि पर निर्भरता है)। यदि आप इसे इसे कहते हैं, तो आप "इकाई परीक्षण" नहीं हैं, आप "एकीकरण परीक्षण" कर रहे हैं

— Vaccano

10

केवल ब्लॉग लेख को न पढ़ें, कई टिप्पणियों को पढ़ें जो इससे असहमत हैं। एक ब्लॉग सिर्फ एक राय है, एक तथ्य नहीं है।

— दान डिपलो

8

@Vaccano: कोई साइड-इफेक्ट या बाहरी स्थिति के साथ एक स्थिर विधि कार्यात्मक रूप से एक मूल्य के बराबर है। यह जानते हुए कि, यह एक पूर्णांक बनाने वाली विधि के परीक्षण से अलग नहीं है। यह एक महत्वपूर्ण अंतर्दृष्टि है जो कार्यात्मक प्रोग्रामिंग हमें देता है।

— स्टीवन एवर्स

3

एम्बेडेड सिस्टम काम करते हैं या ऐसा ऐप जिसके बग्स में अंतर्राष्ट्रीय घटनाएं, IMO बनाने की क्षमता होती है, जब "परीक्षणनीयता" वास्तुकला को चलाती है, तो आपने पहली बार परीक्षण-हर-आखिरी-कोने-पद्धति को अपनाने से पहले इसे घुमा दिया था। इसके अलावा, मैं हर बातचीत पर हावी होने वाली हर चीज के XP के संस्करण से थक गया हूं। XP एक प्राधिकरण नहीं है, यह एक उद्योग है। यहां इकाई परीक्षण की मूल, समझदार परिभाषा है: python.net/crew/tbryan/UnitTestTalk/slide2.html

— एरिक रेपेने

5

सरल सत्य शायद ही कभी स्वीकार किया जाता है कि यदि किसी वर्ग में किसी अन्य वर्ग पर संकलक-दृश्यता निर्भरता होती है, तो उसे उस वर्ग के अलगाव में नहीं देखा जा सकता है। आप परीक्षण की तरह दिखने वाली किसी चीज़ को नकली बना सकते हैं, और रिपोर्ट पर ऐसा प्रतीत होगा जैसे कि यह एक परीक्षण था।

लेकिन इसमें किसी परीक्षण के महत्वपूर्ण परिभाषित गुण नहीं होंगे; जब चीजें गलत होती हैं, तब असफल होना जब वे सही होते हैं।

यह किसी भी स्थिर कॉल, कंस्ट्रक्टर कॉल्स, और बेस क्लास या इंटरफ़ेस से विरासत में मिली विधियों या क्षेत्रों के संदर्भ में लागू होता है । यदि कोड में वर्ग का नाम दिखाई देता है, तो यह एक संकलक-दृश्यमान निर्भरता है, और आप इसके बिना वैध रूप से परीक्षण नहीं कर सकते। कोई भी छोटा हिस्सा केवल एक मान्य परीक्षण योग्य इकाई नहीं है । इसे मानने का कोई भी प्रयास अगर ऐसा होता है, तो आपके टेस्ट फ्रेमवर्क द्वारा प्रयुक्त XML को 'टेस्ट पास' कहने के लिए उपयोग करने के लिए थोड़ी सी उपयोगिता लिखने से ज्यादा सार्थक परिणाम नहीं होगा।

यह देखते हुए कि, तीन विकल्प हैं:

एक वर्ग से बनी इकाई का परीक्षण करने के लिए इकाई परीक्षण को परिभाषित करें और यह हार्ड-कोडित निर्भरता है। यह काम करता है, बशर्ते आप परिपत्र निर्भरता से बचें।
परीक्षण के लिए जिम्मेदार वर्गों के बीच कभी भी संकलन-समय निर्भरता न बनाएं। यह काम करता है, बशर्ते आपको परिणामी कोड शैली से कोई आपत्ति न हो।
यूनिट टेस्ट, इंटीग्रेशन टेस्ट नहीं। जो काम करता है, यह प्रदान करने के लिए कुछ और के साथ संघर्ष नहीं करता है जिसे आपको शब्द एकीकरण परीक्षण के लिए उपयोग करने की आवश्यकता है।

— soru
स्रोत

3

ऐसा कुछ भी नहीं है जो कहता है कि एक इकाई परीक्षण एक एकल वर्ग का परीक्षण है। यह एक एकल इकाई का परीक्षण है। यूनिट परीक्षणों के परिभाषित गुण हैं कि वे तेज, दोहराए जाने वाले और स्वतंत्र हैं। Math.Piएक विधि में संदर्भित करना किसी भी उचित परिभाषा से इसे एकीकरण परीक्षण नहीं बनाता है।

— सारा

विकल्प विकल्प 1. मैं मानता हूं कि यह सबसे अच्छा तरीका है, लेकिन यह जानना उपयोगी हो सकता है कि अन्य लोग शर्तों का अलग-अलग (उचित रूप से या नहीं) उपयोग करते हैं।

— सोरू

4

इसके बारे में कोई दो तरीके नहीं हैं। ReSharper के सुझाव और C # के कई उपयोगी फीचर्स का उपयोग तब नहीं किया जाएगा जब आप अपने सभी कोड के लिए अलग-अलग परमाणु इकाई परीक्षण लिख रहे थे।

उदाहरण के लिए, यदि आपके पास एक स्थिर विधि है और आपको इसे बाहर निकालने की आवश्यकता है, तो आप तब तक नहीं कर सकते जब तक आप प्रोफ़ाइल आधारित आइसोलेशन फ्रेमवर्क का उपयोग नहीं करते। लैम्बडा नोटेशन का उपयोग करने के लिए विधि के शीर्ष को बदलने के लिए कॉल-संगत वर्कअराउंड है। उदाहरण के लिए:

इससे पहले:

    public static DBConnection ConnectToDB( string dbName, string connectionInfo ) {
    }

उपरांत:

    public static Func<string, string, DBConnection> ConnectToDB (dbName, connectionInfo ) {
    };

दो कॉल-संगत हैं। कॉलर को बदलना नहीं है। फ़ंक्शन का शरीर समान रहता है।

फिर अपने यूनिट-टेस्ट कोड में, आप इस कॉल को इस तरह स्टब कर सकते हैं (यह एक डेटाबेस नामक कक्षा में है):

        Database.ConnectToDB = (dbName, connectionInfo) => { return null|whatever; }

आपके द्वारा किए जाने के बाद मूल मूल्य के साथ इसे बदलने के लिए सावधान रहें। आप एक कोशिश के माध्यम से / आखिरकार या अपने यूनिट-टेस्ट में सफाई कर सकते हैं, जिसे हर परीक्षा के बाद बुलाया जाता है, इस तरह से कोड लिखें:

    [TestCleanup]
    public void Cleanup()
    {
        typeof(Database).TypeInitializer.Invoke(null, null);
    }

जो आपकी कक्षा के स्थिर इनिशियलाइज़र को फिर से लागू करेगा।

लैम्ब्डा फंक नियमित स्थैतिक तरीकों के रूप में समर्थन में समृद्ध नहीं है, इसलिए इस दृष्टिकोण के निम्नलिखित अवांछनीय प्रभाव हैं:

यदि स्थैतिक विधि एक विस्तार विधि थी, तो आपको इसे पहले एक गैर-विस्तार विधि में बदलना होगा। Resharper आपके लिए यह स्वचालित रूप से कर सकता है।
यदि किसी भी प्रकार के स्टैटिक तरीके एक एम्बेडेड-इंटरोप असेंबली हैं, जैसे कि ऑफिस के लिए, आपको विधि को लपेटना होगा, टाइप को लपेटना होगा या इसे टाइप करके 'ऑब्जेक्ट' में बदलना होगा।
अब आप Resharper के परिवर्तन-हस्ताक्षर रिफैक्टरिंग उपकरण का उपयोग नहीं कर सकते।

लेकिन मान लीजिए कि आप स्टैटिक्स से पूरी तरह बचते हैं, और आप इसे एक इंस्टेंस विधि में बदल देते हैं। यह तब भी नकली नहीं है जब तक कि विधि आभासी न हो या इंटरफ़ेस के भाग के रूप में कार्यान्वित न हो।

इसलिए वास्तव में, जो कोई भी स्थिर तरीकों को ठोकर मारने के उपाय का सुझाव देता है, वह उन्हें उदाहरण के तरीके बनाने के लिए है, वे उदाहरण के तरीकों के खिलाफ भी होंगे जो आभासी या इंटरफ़ेस का हिस्सा नहीं हैं।

तो C # में स्थिर विधियाँ क्यों है? यह गैर-आभासी उदाहरण के तरीकों की अनुमति क्यों देता है?

यदि आप इन "सुविधाओं" में से किसी एक का उपयोग करते हैं, तो आप केवल पृथक तरीके नहीं बना सकते हैं।

तो आप उनका उपयोग कब करते हैं?

किसी भी कोड के लिए उनका उपयोग करें, जिसकी आपको उम्मीद नहीं है कि कोई भी कभी भी स्टब आउट करना चाहता है। कुछ उदाहरण: स्ट्रिंग क्लास का स्वरूप () विधि कंसोल क्लास (विधि) कंसोल क्लास की विधि () मैथ क्लास की विधि

और एक और बात .. ज्यादातर लोग इस बारे में परवाह नहीं करेंगे, लेकिन अगर आप एक अप्रत्यक्ष कॉल के प्रदर्शन के बारे में कर सकते हैं, तो यह उदाहरण के तरीकों से बचने का एक और कारण है। ऐसे मामले हैं जब यह एक प्रदर्शन हिट है। इसलिए गैर-आभासी तरीके पहले स्थान पर मौजूद हैं।

— zumalifeguard
स्रोत

3

मेरा मानना है कि यह आंशिक रूप से है क्योंकि स्थिर विधियाँ उदाहरण के तरीकों की तुलना में "तेज" हैं। (उद्धरण में क्योंकि यह सूक्ष्म अनुकूलन की खुशबू आ रही है) http://dotnetperls.com/static-method देखें
यह आपको बता रहा है कि इसे राज्य की आवश्यकता नहीं है, इसलिए अगर कहीं से किसी को ज़रूरत हो तो ही अस्थिरता को दूर करके कहीं से भी कॉल किया जा सकता है।
अगर मैं इसका मजाक बनाना चाहता हूं, तो मुझे लगता है कि यह आम तौर पर प्रथा है कि यह एक इंटरफ़ेस पर घोषित किया गया है।
यदि इसे एक इंटरफ़ेस पर घोषित किया जाता है तो R # आपको इसे स्थिर बनाने का सुझाव नहीं देगा।
यदि इसे आभासी घोषित किया जाता है, तो R # आपको यह स्थिर बनाने का सुझाव नहीं देगा।
स्टेट (फ़ील्ड) स्टेटिक रूप से एक ऐसी चीज़ है जिसे हमेशा ध्यान से माना जाना चाहिए । स्टेटिक स्टेट और थ्रेड्स लिथियम और पानी की तरह मिक्स होते हैं।

R # एकमात्र उपकरण नहीं है जो यह सुझाव देगा। FxCop / MS कोड विश्लेषण भी यही करेगा।

मैं आमतौर पर कहूंगा कि यदि विधि स्थिर है, तो आम तौर पर यह परीक्षण योग्य होना चाहिए और साथ ही साथ। यह कुछ डिजाइन पर विचार करता है और शायद मेरी उंगलियों की तुलना में अधिक चर्चा है, इसलिए धैर्य से वोट और टिप्पणियों का इंतजार कर रहा है ...);

— एमआईए
स्रोत

क्या आप एक इंटरफ़ेस पर एक स्थिर विधि / वस्तु की घोषणा कर सकते हैं? (मुझे ऐसा नहीं लगता है)। ईथर का तरीका, मैं यह जिक्र कर रहा हूं कि आपके स्थैतिक विधि को परीक्षण के तहत विधि द्वारा कहा जाता है। यदि कॉलर एक अलग इकाई में है, तो स्थिर विधि को अलग करने की आवश्यकता है। यह ऊपर सूचीबद्ध तीन उपकरणों में से एक के साथ करना बहुत कठिन है।

— 15

1

नहीं, आप एक इंटरफ़ेस पर स्टेटिक की घोषणा नहीं कर सकते। यह व्यर्थ होगा।

— मिया

3

मैं देख रहा हूं कि लंबे समय के बाद किसी ने भी वास्तव में एक साधारण तथ्य नहीं बताया है। यदि पुनर्विक्रेता मुझसे कहता है कि मैं एक विधि को स्थिर बना सकता हूं, तो इसका मतलब मेरे लिए बहुत बड़ी बात है, मैं उसकी आवाज सुन सकता हूं मुझे बताएं: "हे, तुम, तर्क के ये टुकड़े वर्तमान वर्ग की RESPONSIBILITY को संभालने के लिए नहीं हैं, इसलिए इसे बाहर रहना चाहिए कुछ सहायक वर्ग या कुछ में "।

— g1ga
स्रोत

2

मैं असहमत हूं। अधिकांश समय जब रेस्परर कहता है कि मैं कुछ स्थिर कर सकता हूं यह थोड़ा सा कोड है जो कक्षा में दो या दो से अधिक तरीकों के लिए सामान्य था और इस प्रकार मैंने इसे खुद की प्रक्रिया के लिए निकाला। एक सहायक की ओर बढ़ना अर्थहीन जटिलता होगी।

— लोरेन Pechtel

2

मैं आपकी बात को केवल तभी देख सकता हूं जब डोमेन बहुत सरल है और यह भविष्य के संशोधन के लिए उपयुक्त नहीं है। अलग-अलग, जिसे आप "अर्थहीन जटिलता" कहते हैं, यह मेरे लिए अच्छा और मानव-पठनीय डिज़ाइन है। सरल और स्पष्ट कारण के साथ एक सहायक वर्ग होने के लिए किसी तरह SoC और एकल जिम्मेदारी सिद्धांतों के "मंत्र" है। इसके अलावा, यह देखते हुए कि यह नया वर्ग मुख्य के लिए एक निर्भरता बन जाता है, इसे कुछ सार्वजनिक सदस्यों को बेनकाब करना पड़ता है, और एक प्राकृतिक परिणाम के रूप में यह अलगाव में परीक्षण योग्य हो जाता है और जब निर्भरता के रूप में कार्य करने में आसानी होती है।

— जी

1

प्रश्न के लिए प्रासंगिक नहीं है।

— Igby Largeman

2

यदि स्थिर विधि को अन्य विधि के अंदर से बुलाया जाता है , तो ऐसी कॉल को रोकना या स्थानापन्न करना संभव नहीं है। इसका मतलब है, ये दो विधियाँ एक एकल इकाई बनाती हैं; किसी भी तरह का यूनिट टेस्ट उन दोनों का परीक्षण करता है।

और अगर यह स्थिर विधि इंटरनेट से बात करती है, डेटाबेस को जोड़ती है, जीयूआई पॉपअप दिखाती है या अन्यथा यूनिट टेस्ट को पूरी तरह से गड़बड़ कर देती है, तो यह बस बिना किसी आसान काम के आसपास होता है। ऐसी विधि जो इस तरह की स्थैतिक विधि को कॉल करती है, बिना रिफैक्ट किए बिना परीक्षण योग्य नहीं होती है, भले ही इसमें बहुत सारे विशुद्ध रूप से कम्प्यूटेशनल कोड हों जो कि यूनिट परीक्षण किए जाने से अत्यधिक लाभान्वित होंगे।

— H22
स्रोत

0

मेरा मानना है कि रेसपेर आपको मार्गदर्शन दे रहा है और इसके साथ सेटअप किए गए कोडिंग दिशानिर्देशों को लागू करता है। जब मैंने Resharper का उपयोग किया है और उसने मुझे बताया है कि एक विधि स्थिर होनी चाहिए यह एक निजी विधि पर होना बाध्य है जो किसी भी उदाहरण चर पर कार्य नहीं करता है।

अब परीक्षण के रूप में इस परिदृश्य के लिए एक मुद्दा नहीं होना चाहिए क्योंकि आप वैसे भी निजी तरीकों का परीक्षण नहीं करना चाहिए।

जब तक स्टेटिक तरीके स्टेटिक टच करते हैं तब स्टेटिक तरीकों की टेस्टिबिलिटी सार्वजनिक होती है, तब यूनिट टेस्टिंग कठिन हो जाती है। व्यक्तिगत रूप से मैं इसे न्यूनतम रखूंगा और जहां तक संभव हो शुद्ध विधियों का उपयोग कर जहां कोई निर्भरता विधि में पारित हो जाती है जिसे परीक्षण स्थिरता के माध्यम से नियंत्रित किया जा सकता है। हालाँकि यह एक डिजाइन निर्णय है।

— aqwert
स्रोत

मैं इस बात का उल्लेख कर रहा हूं कि जब आपके पास परीक्षण के लिए एक विधि है (स्थिर नहीं) जो किसी अन्य वर्ग में स्थैतिक विधि को बुलाता है। यह निर्भरता केवल ऊपर सूचीबद्ध तीन उपकरणों में से एक के साथ पृथक हो सकती है। यदि आप इसे अलग नहीं करते हैं तो आप एकीकरण परीक्षण कर रहे हैं, इकाई परीक्षण नहीं।

— 15

उदाहरण के चर तक पहुँचने का अर्थ है कि यह स्थिर नहीं हो सकता। एक ही स्टेट स्टेटिक विधि में संभवतः क्लास वेरिएबल हो सकते हैं और एकमात्र कारण यह होना चाहिए कि यदि आप एक सिंगलटन के साथ काम कर रहे हैं और इस प्रकार आपके पास कोई विकल्प नहीं है।

— लोरेन Pechtel