sealed कीवर्ड का अर्थ है कि क्लास से विरासत नहीं ली जा सकती। कंस्ट्रक्टर को private घोषित करने का अर्थ है कि क्लास के इंस्टेंस नहीं बनाए जा सकते।
आप एक बेस क्लास के साथ प्राइवेट कंस्ट्रक्टर रख सकते हैं, लेकिन फिर भी उस बेस क्लास से विरासत ले सकते हैं, कुछ पब्लिक कंस्ट्रक्टर परिभाषित कर सकते हैं, और प्रभावी रूप से उस बेस क्लास को इंस्टेंटिएट कर सकते हैं।
कंस्ट्रक्टर विरासत में नहीं मिलते (इसलिए डेराइव्ड क्लास के पास केवल इसलिए सभी प्राइवेट कंस्ट्रक्टर नहीं होंगे क्योंकि बेस क्लास के पास हैं), और डेराइव्ड क्लासेस हमेशा पहले बेस क्लास कंस्ट्रक्टर को कॉल करती हैं।
क्लास को sealed मार्क करने से कोई आपकी सावधानीपूर्वक निर्मित सिंगलटन क्लास को तुच्छ तरीके से बायपास नहीं कर सकता क्योंकि यह किसी को क्लास से विरासत लेने से रोकता है।
उदाहरण: सील्ड के बिना सिंगलटन (भेद्य)
static class Program
{
static void Main(string[] args)
{
Singleton fromStudent = Singleton.GetInstance;
fromStudent.PrintDetails("From Student");
Singleton fromEmployee = Singleton.GetInstance;
fromEmployee.PrintDetails("From Employee");
Console.WriteLine("-------------------------------------");
// समस्या: कोई DerivedSingleton बना सकता है और नए इंस्टेंस बना सकता है!
Singleton.DerivedSingleton derivedObj = new Singleton.DerivedSingleton();
derivedObj.PrintDetails("From Derived");
Console.ReadLine();
}
}
public class Singleton
{
private static int counter = 0;
private static object obj = new object();
private Singleton()
{
counter++;
Console.WriteLine("Counter Value " + counter.ToString());
}
private static Singleton instance = null;
public static Singleton GetInstance
{
get
{
if (instance == null)
instance = new Singleton();
return instance;
}
}
public void PrintDetails(string message)
{
Console.WriteLine(message);
}
// समस्या: नेस्टेड क्लास विरासत ले सकती है और नए इंस्टेंस बना सकती है!
public class DerivedSingleton : Singleton { }
}आउटपुट (सील्ड के बिना)
Counter Value 1
From Student
From Employee
-------------------------------------
Counter Value 2 <-- नया इंस्टेंस बना! सिंगलटन टूटा!
From Derivedसही कार्यान्वयन: सील्ड सिंगलटन
// थ्रेड-सेफ, सील्ड सिंगलटन
public sealed class Singleton
{
private static readonly Lazy<Singleton> _instance =
new Lazy<Singleton>(() => new Singleton());
private Singleton() { }
public static Singleton Instance => _instance.Value;
public void DoSomething() { Console.WriteLine("Singleton working"); }
}
// उपयोग
var s1 = Singleton.Instance;
var s2 = Singleton.Instance;
Console.WriteLine(s1 == s2); // Trueसील्ड सिंगलटन के फायदे
- विरासत रोकता है: कोई उपक्लास नहीं बना सकता
- JIT ऑप्टिमाइज़ेशन: सील्ड क्लासेस पर वर्चुअल कॉल्स को देवर्चुअलाइज़ किया जा सकता है
- स्पष्ट इरादा: डिज़ाइन स्पष्ट रूप से बताता है "यह क्लास एक्सटेंशन के लिए नहीं है"
- सुरक्षा: दुर्भावनापूर्ण या आकस्मिक उपवर्गीकरण को रोकता है
आधुनिक C# में सिंगलटन के विकल्प
// 1. Lazy<T> (थ्रेड-सेफ, आलसी)
public sealed class Singleton
{
private static readonly Lazy<Singleton> _instance = new(() => new Singleton());
private Singleton() { }
public static Singleton Instance => _instance.Value;
}
// 2. Static क्लास (यदि कोई स्थिति नहीं)
public static class Logger { public static void Log(string msg) { ... } }
// 3. DI कंटेनर में पंजीकरण (अनुशंसित)
services.AddSingleton<IService, ServiceImpl>();सारांश
sealed सिंगलटन पैटर्न की अखंडता सुनिश्चित करता है विरासत को रोककर, जो अन्यथा एकाधिक इंस्टेंस बनाने और पैटर्न को तोड़ने की अनुमति देगा।
