C # - ओवरकिल की तरह कोई मार नहीं है
सबसे पहले, प्रिय GiMmEtHaCoDeZ, आइए अपने कार्य को तोड़ने का प्रयास करें:
- संख्या पढ़ें
- उन्हें क्रमबद्ध करें
- क्रमबद्ध संख्याओं को आउटपुट करें।
सॉफ़्टवेयर समस्याओं के साथ काम करते समय "डिवाइड एंड कॉनकर" बहुत महत्वपूर्ण रणनीति है, जो उन्हें एक समय में निपटने की सुविधा देता है
1. पढ़ना
सॉफ्टवेयर में एक और महत्वपूर्ण मुद्दा बहुमुखी प्रतिभा है। चूंकि यह निर्दिष्ट नहीं है कि उपयोगकर्ता संख्याओं को कैसे इनपुट करेगा, जो कंसोल के माध्यम से, एक फ़ाइल के माध्यम से, एक वेब सेवा के माध्यम से हो सकता है, आदि। शायद कुछ विधि भी जो हम इस समय नहीं सोच सकते हैं। इसलिए, यह महत्वपूर्ण है कि हमारा समाधान विभिन्न प्रकार के इनपुट को समायोजित करने में सक्षम होगा। इसे प्राप्त करने का सबसे आसान तरीका एक इंटरफ़ेस में महत्वपूर्ण हिस्सा निकालना होगा, आइए बताते हैं
public interface IDoubleArrayReader
{
IEnumerable<double> GetDoubles();
DoubleArrayReaderType Type {get;}
}
जहां DoubleArrayReaderTypeएक गणना दी गई है
public enum DoubleArrayReaderType
{
Console,
File,
Database,
Internet,
Cloud,
MockService
}
सॉफ्टवेयर को जमीन से ऊपर तक परीक्षण योग्य बनाना भी महत्वपूर्ण है, इसलिए इंटरफ़ेस का कार्यान्वयन होगा
public class MockServiceDoubleArrayReader : IDoubleArrayReader
{
IEnumerable<double> IDoubleArrayReader.GetDoubles()
{
Random r = new Random();
for(int i =0; i<=10; i++)
{
yield return r.NextDouble();
}
}
DoubleArrayReaderType IDoubleArrayReader.Type
{
get
{
return DoubleArrayReaderType.MockService;
}
}
}
अगला, तार्किक प्रश्न यह है कि हम IDoubleArrayReaderकोड में उपयुक्त लोड करने के लिए कैसे जानेंगे । जब तक हम एक साधारण कारखाने का उपयोग करते हैं, तब तक यह आसान है:
public static class DoubleArrayInputOutputFactory
{
private static Dictionary<DoubleArrayReaderType, IDoubleArrayReader> readers;
static DoubleArrayInputOutputFactory()
{
readers = new Dictionary<DoubleArrayReaderType, IDoubleArrayReader>();
foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
{
try
{
var instance = Activator.CreateInstance(type);
if (instance is IDoubleArrayReader)
{
readers.Add((instance as IDoubleArrayReader).Type,
(instance as IDoubleArrayReader));
}
}
catch
{
continue;
}
}
}
public static IDoubleArrayReader CreateDoubleArrayReader(DoubleArrayReaderType type)
{
return readers[type];
}
}
ध्यान दें कि, हम सभी सक्रिय पाठकों को लोड करने के लिए प्रतिबिंब का उपयोग करते हैं, इसलिए भविष्य के किसी भी एक्सटेंशन को स्वचालित रूप से अब उपलब्ध होगा, मुख्य बॉडी आउट कोड के रूप में:
IDoubleArrayReader reader = DoubleArrayInputOutputFactory
.CreateDoubleArrayReader(DoubleArrayReaderType.MockService);
var doubles = reader.GetDoubles();
2. प्रसंस्करण (छँटाई)
अब हमें प्रोसेस करने की जरूरत है, यानी हमारे द्वारा हासिल किए गए नंबरों को सॉर्ट करें। ध्यान दें कि चरण एक-दूसरे से पूरी तरह से स्वतंत्र हैं, इसलिए सॉर्टिंग सबसिस्टम के लिए, इससे कोई फर्क नहीं पड़ता कि नंबर कैसे इनपुट किए गए थे। इसके अतिरिक्त, सॉर्टिंग व्यवहार भी कुछ ऐसा है जो परिवर्तन के अधीन है, उदाहरण के लिए हमें जगह में अधिक कुशल सॉर्टिंग एल्गोरिथ्म इनपुट करना पड़ सकता है। इसलिए, स्वाभाविक रूप से, हम एक इंटरफ़ेस में अनुरोध किए गए प्रसंस्करण व्यवहार को निकालेंगे:
public interface IDoubleArrayProcessor
{
IEnumerable<double> ProcessDoubles(IEnumerable<double> input);
DoubleArrayProcessorType Type {get;}
}
public enum DoubleArrayProcessorType
{
Sorter,
Doubler,
Tripler,
Quadrupler,
Squarer
}
और सॉर्टिंग व्यवहार केवल इंटरफ़ेस को लागू करेगा:
public class SorterDoubleArrayProcessor : IDoubleArrayProcessor
{
IEnumerable<double> IDoubleArrayProcessor.ProcessDoubles(IEnumerable<double> input)
{
var output = input.ToArray();
Array.Sort(output);
return output;
}
DoubleArrayProcessorType IDoubleArrayProcessor.Type
{
get
{
return DoubleArrayProcessorType.Sorter;
}
}
}
बेशक, हमें प्रसंस्करण इंस्टेंस को लोड और प्रबंधित करने के लिए एक कारखाने की आवश्यकता होगी।
public static class DoubleArrayProcessorFactory
{
private static Dictionary<DoubleArrayProcessorType, IDoubleArrayProcessor> processors;
static DoubleArrayProcessorFactory()
{
processors = new Dictionary<DoubleArrayProcessorType, IDoubleArrayProcessor>();
foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
{
try
{
var instance = Activator.CreateInstance(type);
if (instance is IDoubleArrayProcessor)
{
processors.Add((instance as IDoubleArrayProcessor).Type, (instance as IDoubleArrayProcessor));
}
}
catch
{
continue;
}
}
}
public static IDoubleArrayProcessor CreateDoubleArrayProcessor(DoubleArrayProcessorType type)
{
return processors[type];
}
}
3. आउटपुट लिखना
यहां कहने के लिए बहुत कुछ नहीं है, क्योंकि यह एक प्रक्रिया है जो इनपुट को प्रतिबिंबित करती है। वास्तव में, हम पठन और लेखन कारखानों को एक में मिला सकते हैं DoubleArrayInputOutputFactory, जैसे:
public interface IDoubleArrayWriter
{
void WriteDoublesArray(IEnumerable<double> doubles);
DoubleArrayWriterType Type {get;}
}
public enum DoubleArrayWriterType
{
Console,
File,
Internet,
Cloud,
MockService,
Database
}
public class ConsoleDoubleArrayWriter : IDoubleArrayWriter
{
void IDoubleArrayWriter.WriteDoublesArray(IEnumerable<double> doubles)
{
foreach(double @double in doubles)
{
Console.WriteLine(@double);
}
}
DoubleArrayWriterType IDoubleArrayWriter.Type
{
get
{
return DoubleArrayWriterType.Console;
}
}
}
public static class DoubleArrayInputOutputFactory
{
private static Dictionary<DoubleArrayReaderType, IDoubleArrayReader> readers;
private static Dictionary<DoubleArrayWriterType, IDoubleArrayWriter> writers;
static DoubleArrayInputOutputFactory()
{
readers = new Dictionary<DoubleArrayReaderType, IDoubleArrayReader>();
writers = new Dictionary<DoubleArrayWriterType, IDoubleArrayWriter>();
foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
{
try
{
var instance = Activator.CreateInstance(type);
if (instance is IDoubleArrayReader)
{
readers.Add((instance as IDoubleArrayReader).Type, (instance as IDoubleArrayReader));
}
}
catch
{
continue;
}
}
foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
{
try
{
var instance = Activator.CreateInstance(type);
if (instance is IDoubleArrayWriter)
{
writers.Add((instance as IDoubleArrayWriter).Type, (instance as IDoubleArrayWriter));
}
}
catch
{
continue;
}
}
}
public static IDoubleArrayReader CreateDoubleArrayReader(DoubleArrayReaderType type)
{
return readers[type];
}
public static IDoubleArrayWriter CreateDoubleArrayWriter(DoubleArrayWriterType type)
{
return writers[type];
}
}
यह सब एक साथ डालें
अंत में, हमारा मुख्य कार्यक्रम बस हमारे द्वारा पहले से ही निर्मित इस सभी अजीबता का उपयोग करेगा, इसलिए कोड बस होगा:
var doubles = reader.GetDoubles();
doubles = processor.ProcessDoubles(doubles);
writer.WriteDoublesArray(doubles);
जहाँ, जैसे हम परिभाषित कर सकते हैं reader, writerऔर processorउपयोग कर सकते हैं
IDoubleArrayReader reader = DoubleArrayInputOutputFactory.CreateDoubleArrayReader(DoubleArrayReaderType.MockService);
IDoubleArrayProcessor processor = DoubleArrayProcessorFactory.CreateDoubleArrayProcessor(DoubleArrayProcessorType.Sorter);
IDoubleArrayWriter writer = DoubleArrayInputOutputFactory.CreateDoubleArrayWriter(DoubleArrayWriterType.Console);