मैं स्थैतिक कक्षाएं क्यों नहीं ले सकता हूं?

Question

मेरे पास कई वर्ग हैं जिन्हें वास्तव में किसी राज्य की आवश्यकता नहीं है। संगठनात्मक दृष्टिकोण से, मैं उन्हें पदानुक्रम में रखना चाहूंगा।

लेकिन ऐसा लगता है कि मैं स्थैतिक वर्गों के लिए विरासत घोषित नहीं कर सकता।

ऐसा कुछ:

public static class Base
{
}

public static class Inherited : Base
{
}

काम नहीं करेगा।

भाषा के डिजाइनरों ने उस संभावना को क्यों बंद कर दिया है?

Comments

के संभावित डुप्लिकेट कैसे एक स्थिर वर्ग एक वस्तु से निकाले जाते हैं कर सकते हैं?

— मोसमेल बेन ढोउ

Answer 1

यहाँ से उद्धरण :

यह वास्तव में डिजाइन द्वारा है। ऐसा प्रतीत होता है कि एक स्थिर वर्ग के वारिस होने का कोई अच्छा कारण नहीं है। इसमें सार्वजनिक स्थैतिक सदस्य होते हैं जिन्हें आप हमेशा क्लास नाम से ही एक्सेस कर सकते हैं। स्थैतिक सामानों को विरासत में पाने के लिए मैंने जो एकमात्र कारण देखे हैं, वे बुरे हैं, जैसे कि टाइपिंग के कुछ पात्रों को सहेजना।

स्थैतिक सदस्यों को सीधे दायरे में लाने के लिए तंत्र पर विचार करने का कारण हो सकता है (और हम वास्तव में ऑर्कास उत्पाद चक्र के बाद इस पर विचार करेंगे), लेकिन स्थैतिक वर्ग उत्तराधिकार जाने का तरीका नहीं है: यह उपयोग करने के लिए गलत तंत्र है, और काम करता है केवल स्थिर सदस्यों के लिए जो एक स्थिर वर्ग में रहते हैं।

(मैड्स टॉर्गेसेन, सी # भाषा पीएम)

Channel9 से अन्य राय

.NET में वंशानुक्रम केवल उदाहरण के आधार पर काम करता है। स्टेटिक तरीकों को उदाहरण के स्तर पर नहीं प्रकार के स्तर पर परिभाषित किया जाता है। यही कारण है कि ओवरराइडिंग स्टैटिक विधियों / गुणों / घटनाओं के साथ काम नहीं करता है ...

मेमोरी में स्टैटिक तरीके केवल एक बार आयोजित किए जाते हैं। कोई वर्चुअल टेबल आदि नहीं है जो उनके लिए बनाई गई हो।

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

(Littleguru)

और एक मूल्यवान विचार के रूप में, इस मुद्दे के लिए लिटिलगुरु के पास आंशिक "वर्कअराउंड" है: सिंगलटन पैटर्न।

Comments

Torgersen के पक्ष में कल्पना की कमी, वास्तव में। मेरे पास ऐसा करने का एक बहुत अच्छा कारण था :)

— थोरारिन

इस बारे में कैसा है? आपके पास एक dll है जो खुला स्रोत नहीं है / आपके पास इसके स्रोत तक पहुंच नहीं है, आइए NUnit कहते हैं। आप इसका विस्तार करना चाहते हैं कि थ्रो </ b> (ए) (हां) की तरह एक विधि है, लेकिन यह भी है, लेकिन एक बिंदु पर यह नहीं है।) आप अपनी परियोजना में एक एस्टर जोड़ सकते हैं: NUnit.Framework.Assert वर्ग, और फिर एक फेंकता विधि जोड़ें। समस्या सुलझ गयी। यह कोड में उपयोग करने के लिए क्लीनर भी है ... एक और classname के साथ आने और उस classname को याद रखने के बजाय, बस Assert टाइप करें। और उपलब्ध तरीकों को देखें।

— user420667

@KonradMorawski स्थिर वर्गों के लिए विस्तार विधियों को लिखना असंभव है। stackoverflow.com/questions/249222/…

— मार्टिन ब्रौन

@modiX बेशक। आपने मुझे यहाँ गलत समझा। मेरा मतलब यह है कि user420667 द्वारा वर्णित परिदृश्य में आवश्यक कार्यक्षमता ( भविष्य में ) स्थिर वर्गों के लिए विस्तार के तरीकों की अनुमति देकर प्रदान की जा सकती है । कोई स्थिर वंशानुक्रम आवश्यक नहीं है। यही कारण है कि स्थैतिक विरासत की शुरुआत करने के लिए उनके परिदृश्य ने मुझे बहुत अच्छा औचित्य नहीं दिया। यदि इस पहलू में C # को संशोधित किया जाना था, तो एक प्रमुख रिडिजाइन के लिए क्यों जाएं जब एक नाबालिग व्यवहार में उतना ही अच्छा होगा।

— कोनराड मोरावस्की

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

— RenniePet

Answer 2

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

तो यह:

static class Foo { }

इस IL के संकलन:

.class private abstract auto ansi sealed beforefieldinit Foo
  extends [mscorlib]System.Object
 {
 }

Comments

आप कह रहे हैं कि स्थैतिक को अमूर्त + सील के रूप में लागू किया गया था। वह जानना चाहता है कि ऐसा क्यों किया गया। इसे क्यों सील किया गया?

— लुकास

यह इस सवाल का जवाब नहीं देता है; यह सिर्फ उस मुद्दे को शांत करता है जिसके बारे में वह पूछ रहा था।

— Igby Largeman

ठीक है, ओपी को पूछा जाना चाहिए कि "स्टैटिक क्लास को क्यों सील किया जाता है", न कि "मैं स्टैटिक क्लास से इनहेरिट क्यों नहीं कर सकता?", जिसका उत्तर निश्चित रूप से "क्योंकि वे सील हैं" । इस जवाब को मेरा वोट मिलता है।

— एलेक्स बुडोव्स्की

साझा करने के लिए धन्यवाद कि स्थैतिक कक्षाएं स्वचालित रूप से सील की गई कक्षाओं के रूप में संकलित हो जाती हैं - मैं सोच रहा था कि ऐसा कैसे / कब हुआ!

— मार्क

@AlexBudovski: यह उत्तर सही है, लेकिन एक खोए हुए व्यक्ति के रूप में बेकार के रूप में "आप मेरे सामने हैं" जब वे आपसे पूछते हैं "मैं कहां हूं"।

— दीपस्पेस १०

Answer 3

इसके बारे में इस तरह से सोचें: आप स्थैतिक सदस्यों को प्रकार नाम के माध्यम से एक्सेस करते हैं, जैसे:

MyStaticType.MyStaticMember();

क्या आप उस वर्ग से विरासत में थे, आपको इसे नए प्रकार के नाम से एक्सेस करना होगा:

MyNewType.MyStaticMember();

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

शायद आप सोच रहे हैं कि आप मूल कक्षा में कुछ वस्तुओं का विस्तार करना चाहते हैं। उस स्थिति में, आपको नए प्रकार में मूल के सदस्य का उपयोग करने से कुछ भी नहीं रोक सकता है।

शायद आप मौजूदा स्थैतिक प्रकार के तरीकों को जोड़ना चाहते हैं। आप विस्तार विधियों के माध्यम से पहले से ही ऐसा कर सकते हैं।

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

तो, अंत में आप वास्तव में स्थिर वर्गों को प्राप्त करने से कुछ हासिल नहीं करते हैं।

Comments

आप एक्सटेंशन पद्धति के माध्यम से मौजूदा स्थिर प्रकार में विधियाँ नहीं जोड़ सकते। कृपया वांछित उपयोग के लिए स्वीकृत उत्तर पर मेरी टिप्पणी देखें। (मूल रूप से आप MyNewType को MyStaticType नाम देना चाहते हैं, बस उसका नाम बदलना चाहते हैं, इसलिए MyStaticType: OldProject.MyStaticType)

— user420667

कोई व्यक्ति स्थैतिक प्रकारों और आभासी स्थैतिक सदस्यों के साथ विरासत के संबंधों को इस तरह से परिभाषित कर सकता है कि वह SomeClass<T> where T:Fooसदस्यों तक पहुंच सकता है Foo, और यदि Tएक वर्ग था जो कुछ आभासी स्थैतिक सदस्यों को Fooओवरराइड करता है, तो सामान्य वर्ग उन ओवरराइड्स का उपयोग करेगा। संभवतः एक सम्मेलन को परिभाषित करना भी संभव होगा जिसके माध्यम से भाषाएं वर्तमान सीएलआर के अनुरूप फैशन में ऐसा कर सकती हैं (जैसे कि ऐसे सदस्यों के साथ एक वर्ग को एक संरक्षित गैर-स्थिर वर्ग को परिभाषित करना चाहिए जिसमें ऐसे उदाहरण सदस्य हों, जिनके साथ एक स्थिर क्षेत्र भी हो। उस प्रकार का एक उदाहरण पकड़े हुए)।

— सुपरकैट

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

— लोरेन Pechtel

Answer 4

वर्ग पदानुक्रम का उपयोग करके आप जो हासिल करना चाहते हैं वह केवल नाम स्थान के माध्यम से प्राप्त किया जा सकता है। ऐसे नाम जो नाम-पत्र का समर्थन करते हैं (जैसे C #) में स्थिर वर्गों की श्रेणी पदानुक्रम को लागू करने का कोई फायदा नहीं होगा। चूँकि आप किसी भी वर्ग को त्वरित नहीं कर सकते हैं, आप सभी को वर्ग परिभाषाओं का एक पदानुक्रमित संगठन है जिसे आप नेमस्पेस के उपयोग के माध्यम से प्राप्त कर सकते हैं

Comments

मेरे पास एक सामान्य लोडर है जो टाइप के रूप में एक वर्ग प्राप्त करता है। उस वर्ग में 5 सहायक विधियाँ और 2 विधियाँ हैं जो एक स्ट्रिंग (नाम और विवरण) लौटाती हैं। हो सकता है कि मैंने इसे गलत चुना हो (मुझे ऐसा लगता है), लेकिन मुझे जो एकमात्र समाधान मिला वह था सामान्य तरीके से क्लास को इंस्टेंट करना, तरीकों तक पहुँचने के लिए ... meh।

— एविएव्स

विकल्प एक विशाल शब्दकोश होगा, मुझे लगता है। इसके अलावा, जब आप कहते हैं कि "आप क्या हासिल करना चाहते हैं" तो आपको इसके बजाय कहना चाहिए "जो आप लक्ष्य करना चाहते हैं" या ऐसा ही कुछ।

— एविव्स

Answer 5

आप इसके बजाय संरचना का उपयोग कर सकते हैं ... यह आपको स्थिर प्रकार से वर्ग की वस्तुओं तक पहुंचने की अनुमति देगा। लेकिन फिर भी कैंट इम्प्लांट इंटरफेस या अमूर्त कक्षाएं नहीं लगा सकते

Answer 6

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

इसलिए ... यदि आप स्थैतिक सदस्यों को विरासत में नहीं दे सकते हैं, और यदि स्थिर वर्गों में केवल स्थैतिक सदस्य हो सकते हैं , तो एक स्थिर वर्ग को क्या अच्छा मिलेगा?

Answer 7

हम्मम ... क्या यह बहुत अलग होगा यदि आपके पास सिर्फ गैर-स्थिर कक्षाएं थीं जो स्थिर तरीकों से भरी हुई थीं ..?

Comments

यही मेरे लिए बचा है। मैं इसे इस तरह से करता हूं। और मुझे यह पसंद नहीं है।

— यूजर

मैंने इसे इस तरह से भी किया है, लेकिन किसी कारण से यह सौंदर्य महसूस नहीं करता है जब आप जानते हैं कि आप कभी भी ऑब्जेक्ट को तुरंत नहीं करेंगे। मैं हमेशा इस तरह के विवरण के बारे में तड़पता हूं, इस तथ्य के बावजूद कि इसकी कोई सामग्री लागत नहीं है।

— 18

गैर-स्थैतिक वर्ग में भरे हुए स्थिर तरीकों से आप विस्तार विधियों को नहीं डाल सकते हैं :)

— जैकब स्ज़ुक्लाक्विक्ज़

Answer 8

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

public class TestClass<T>
{
    protected TestClass()
    { }

    public static T Add(T x, T y)
    {
        return (dynamic)x + (dynamic)y;
    }
}

public class TestClass : TestClass<double>
{
    // Inherited classes will also need to have protected constructors to prevent people from creating instances of them.
    protected TestClass()
    { }
}

TestClass.Add(3.0, 4.0)
TestClass<int>.Add(3, 4)

// Creating a class instance is not allowed because the constructors are inaccessible.
// new TestClass();
// new TestClass<int>();

दुर्भाग्य से "बाय-डिज़ाइन" भाषा सीमा के कारण हम ऐसा नहीं कर सकते:

public static class TestClass<T>
{
    public static T Add(T x, T y)
    {
        return (dynamic)x + (dynamic)y;
    }
}

public static class TestClass : TestClass<double>
{
}

Answer 9

आप कुछ ऐसा कर सकते हैं जो स्थिर विरासत की तरह दिखाई देगा।

यहाँ चाल है:

public abstract class StaticBase<TSuccessor>
    where TSuccessor : StaticBase<TSuccessor>, new()
{
    protected static readonly TSuccessor Instance = new TSuccessor();
}

तो आप यह कर सकते हैं:

public class Base : StaticBase<Base>
{
    public Base()
    {
    }

    public void MethodA()
    {
    }
}

public class Inherited : Base
{
    private Inherited()
    {
    }

    public new static void MethodA()
    {
        Instance.MethodA();
    }
}

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

स्थैतिक आवरण विधियों के मैनुअल निर्माण की आवश्यकता की तरह डाउनसाइड्स हैं और new कीवर्ड के । लेकिन यह दृष्टिकोण कुछ ऐसी चीज़ों का समर्थन करने में मदद करता है जो वास्तव में स्थिर विरासत के समान हैं।

पुनश्च हमने संकलित क्वेरी बनाने के लिए इसका उपयोग किया, और यह वास्तव में समवर्ती छायांकन के साथ बदला जा सकता है, लेकिन इसकी थ्रेड सुरक्षा के साथ एक स्थिर केवल पढ़ने योग्य फ़ील्ड काफी अच्छा था।

Answer 10

मेरा जवाब: खराब डिजाइन विकल्प। ;-)

यह एक दिलचस्प बहस है जो सिंटैक्स प्रभाव पर केंद्रित है। मेरे विचार में, तर्क का मूल यह है कि एक डिजाइन निर्णय सील किए गए स्थिर वर्गों का नेतृत्व करता है। बाल नामों के पीछे ('भ्रमित') छिपाने के बजाय शीर्ष स्तर पर दिखने वाले स्थिर वर्ग के नामों की पारदर्शिता पर ध्यान केंद्रित किया गया है? एक भाषा कार्यान्वयन की कल्पना कर सकता है जो आधार या बच्चे को सीधे भ्रमित कर सकता है।

एक छद्म उदाहरण, स्थैतिक विरासत को मानते हुए किसी तरह से परिभाषित किया गया था।

public static class MyStaticBase
{
    SomeType AttributeBase;
}

public static class MyStaticChild : MyStaticBase
{
    SomeType AttributeChild;
}

इसके लिए नेतृत्व करेंगे:

 // ...
 DoSomethingTo(MyStaticBase.AttributeBase);
// ...

के रूप में एक ही भंडारण को प्रभावित (जो?) कर सकता है

// ...
DoSomethingTo(MyStaticChild.AttributeBase);
// ...

बहुत ज्यादा उलझन!

लेकिन रुकें! कंपाइलर MyStaticBase और MyStaticChild दोनों में एक ही हस्ताक्षर होने के साथ कैसे निपटेंगे? यदि बच्चा मेरे उपरोक्त उदाहरण से आगे निकल जाता है, तो वही भंडारण नहीं बदलेगा, हो सकता है? इससे और भी भ्रम पैदा होता है।

मेरा मानना ​​है कि सीमित स्थैतिक विरासत के लिए एक मजबूत सूचनात्मक औचित्य है। शीघ्र ही सीमा पर और अधिक। यह छद्मकोड मान दिखाता है:

public static class MyStaticBase<T>
{
   public static T Payload;
   public static void Load(StorageSpecs);
   public static void Save(StorageSpecs);
   public static SomeType AttributeBase
   public static SomeType MethodBase(){/*...*/};
}

फिर आपको मिलता है:

public static class MyStaticChild : MyStaticBase<MyChildPlayloadType>
{
   public static SomeType AttributeChild;
   public static SomeType SomeChildMethod(){/*...*/};
   // No need to create the PlayLoad, Load(), and Save().
   // You, 'should' be prevented from creating them, more on this in a sec...
} 

उपयोग इस तरह दिखता है:

// ...
MyStaticChild.Load(FileNamePath);
MyStaticChild.Save(FileNamePath);
doSomeThing(MyStaticChild.Payload.Attribute);
doSomething(MyStaticChild.AttributeBase);
doSomeThing(MyStaticChild.AttributeChild);
// ...

स्थिर बच्चे का निर्माण करने वाले व्यक्ति को क्रमबद्धता प्रक्रिया के बारे में सोचने की आवश्यकता नहीं है, जब तक कि वे किसी भी सीमा को नहीं समझते हैं जो कि मंच या पर्यावरण के क्रमांकन इंजन पर रखा जा सकता है।

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

मेरा मानना ​​है कि विशिष्ट सीमाओं के साथ स्थिर विरासत की अनुमति देने के लिए सही डिजाइन विकल्प होगा:

1. किसी चीज का ओवरराइड नहीं। बच्चा आधार विशेषताओं, फ़ील्ड्स, या विधियों को प्रतिस्थापित नहीं कर सकता है, ... जब तक कि हस्ताक्षर में अंतर नहीं हो, तब तक ओवरलोडिंग ठीक होनी चाहिए, जिससे कंपाइलर को बच्चे बनाम आधार को सॉर्ट करने की अनुमति मिलती है।
2. केवल सामान्य स्थिर आधारों की अनुमति दें, आप गैर-सामान्य स्थैतिक आधार से विरासत में नहीं मिल सकते।

आप अभी भी उसी स्टोर को जेनेरिक रेफरेंस के जरिए बदल सकते हैं MyStaticBase<ChildPayload>.SomeBaseField। लेकिन आप को हतोत्साहित किया जाएगा क्योंकि सामान्य प्रकार को निर्दिष्ट करना होगा। जबकि बच्चे का संदर्भ क्लीनर होगा MyStaticChild.SomeBaseField:।

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

Answer 11

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

एक वर्ग को स्थिर घोषित किया जा सकता है, जो दर्शाता है कि इसमें केवल स्थिर सदस्य हैं। स्थिर वर्ग के उदाहरण बनाने के लिए नए कीवर्ड का उपयोग करना संभव नहीं है। जब प्रोग्राम लोड किया जाता है या नामस्थान जिसमें क्लास लोड होता है, तो .NET फ्रेमवर्क सामान्य भाषा रनटाइम (CLR) द्वारा स्टेटिक क्लासेस अपने आप लोड हो जाता है।

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

स्थिर वर्ग की मुख्य विशेषताएं निम्नलिखित हैं:

1. इनमें केवल स्थिर सदस्य होते हैं।

2. उन्हें त्वरित नहीं किया जा सकता है।

3. उन्हें सील कर दिया जाता है।

4. उनमें इंस्टेंस कंस्ट्रक्टर (C # प्रोग्रामिंग गाइड) नहीं हो सकते।

एक स्थिर वर्ग बनाना इसलिए मूल रूप से एक ऐसा वर्ग बनाना है जिसमें केवल स्थिर सदस्य और एक निजी कंस्ट्रक्टर हो। एक निजी कंस्ट्रक्टर क्लास को तुरंत होने से रोकता है।

एक स्थिर वर्ग का उपयोग करने का लाभ यह है कि संकलक यह सुनिश्चित करने के लिए जांच कर सकता है कि कोई उदाहरण सदस्य गलती से जोड़ नहीं रहे हैं। कंपाइलर गारंटी देगा कि इस वर्ग के उदाहरण नहीं बनाए जा सकते हैं।

स्थैतिक वर्ग सील कर दिए गए हैं और इसलिए उन्हें विरासत में नहीं मिला जा सकता है। वे ऑब्जेक्ट को छोड़कर किसी भी वर्ग से वारिस नहीं हो सकते। स्टेटिक क्लासेस में एक इंस्टेंस कंस्ट्रक्टर नहीं हो सकता है; हालांकि, उनके पास एक स्थिर निर्माता हो सकता है। अधिक जानकारी के लिए, स्टेटिक कंस्ट्रक्टर्स (C # प्रोग्रामिंग गाइड) देखें।

Answer 12

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