सुरुचिपूर्ण तार

कल्पना कीजिए कि हमें .net में तार के साथ कुछ करने की आवश्यकता है। कुछ बहुत जटिल नहीं है, लेकिन बिल्कुल सरल नहीं है। उदाहरण के लिए, उचित स्वरूपण के लिए, पाठ में अल्पविराम के बाद रिक्त स्थान डालें। .Net बॉक्स से क्या प्रदान करता है?
कुछ इस तरह:

string str = "..."; str.Replace(",", ", "); 

रुको, लेकिन हम रिक्त स्थान रखना चाहते थे, अल्पविराम की जगह नहीं! ...

ठीक है, चलो आगे बढ़ते हैं।
चलो सेंसरशिप शुरू करते हैं। हम अपने ग्रंथों में, "भालू" शब्द की अनुमति नहीं देंगे। तो यह आसान है। हम प्रत्येक "भालू" को एक दीर्घवृत्त के साथ बदल देंगे।
हाँ, विकल्प। इसलिए समान रिप्लेसमेंट विधि का उपयोग करना तार्किक है। जल्द से जल्द नहीं कहा:

 string str = "         .    ,    ."; var result = str.Replace("", "..."); 

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

 string str = "         .    ,    ."; var result = str.Replace("", "...").Replace("", "..."); 

फू, यह निकला। बहुत सुंदर नहीं है, लेकिन यह काम करता है। लेकिन क्या यह काम करता है? अचानक ऐसा "शहद" आता है?
हमने सोचा, इस तरह के विद्रोहियों को भी थकाना और काट देना चाहिए। लेकिन किस कीमत पर!

 string str = "         .    ,    ."; int index = str.IndexOf("", StringComparison.CurrentCultureIgnoreCase); while (index >= 0) { str = str.Remove(index, "".Length); str = str.Insert(index, "..."); index = str.IndexOf("", StringComparison.CurrentCultureIgnoreCase); } 

इस कोड में कुछ गलत है। और दो समस्याएं हैं:

1. प्रतिरक्षा के कारण हर कदम पर लाइनों के फिर से निर्माण के कारण धीमी निष्पादन
2. उपयोगितावादी कोड का एक निम्न-स्तरीय टुकड़ा, जिसे आमतौर पर एक वर्ग में संदर्भित किया जाता है, जिसे Util कहा जाता है और भुला दिया जाता है, एक आकर्षक शब्दार्थ सत्यापित परियोजना के बीच (अच्छी तरह से, क्या आप कल्पनाओं की भी कल्पना कर सकते हैं?)

इसी समय, प्रदर्शन में सुधार करने के लिए एक समाधान है - स्ट्रिंगबर्ल का उपयोग करके फिर से लिखना।
लेकिन एक शांत रूप से गंभीर सौंदर्य भावना के साथ क्या करना है?

आपको यह स्वीकार करना होगा कि मौजूदा .net स्ट्रिंग इंटरफ़ेस पुराना है। यह पुरातन है, पर्याप्त रूप से लचीला नहीं है और आपको बार-बार सामान्य और सरल संचालन के लिए बहुत सारे अजीब कोड लिखते हैं।
अभी तक null जांच करना न भूलें। सूचकांक के सीमा मूल्यों की जाँच करता है। और अगर आप लाइनों की लंबाई को सही ढंग से प्रबंधित करते हैं।

इस तरह से धाराप्रवाह स्ट्रिंग इंटरफेस का विचार पैदा हुआ।
आधुनिक, पठनीय और साथ ही परीक्षण किया हुआ।

देखते हैं कि यह क्या आया।

सम्मिलित ऑपरेशन का एक उदाहरण:

 string t = "      .    !     " .Insert(",    ").After(2, "").IgnoringCase().From(The.Beginning); t.Should().Be("      .    ,    !     "); 

इसे Insert " " after second "" ignoring case from the beginning. रूप में पढ़ा जाता है Insert " " after second "" ignoring case from the beginning. हालाँकि, यह मैं क्या हूँ? और जैसा स्पष्ट है।

हम कुछ हटा देंगे:

 string t = "    ->    ->,    ->" .Remove(2, ""); transformed.Should().Be("    ->    ->,    ->"); 

अब सबकुछ हटा दें, मामला संवेदनशील:

 string t = "       ".RemoveAll("").IgnoringCase(); t.Should().Be("      "); 

या इस तरह भी:

 string t = "Some very long string".RemoveChars('e', 'L', 'G').IgnoringCase(); t.Should().Be("Som vry on strin"); 

और इसलिए:

 string t = "     , ".RemoveVowels().For("ru"); t.Should().Be("     , "); 

मानक तर्क के विस्तार के लिए एक जगह थी:

 bool isEmptyOrWhiteSpace = " ".IsEmpty().OrWhiteSpace(); isEmptyOrWhiteSpace.Should().Be(true); 

वहां पैसेज:

 var indexes = "    ,         " .IndexesOf("").IgnoringCase(); indexes.Should().ContainInOrder(21, 44, 64); 

और पीछे:

 var indexes = "    ,         " .IndexesOf("").From(The.End); indexes.Should().ContainInOrder(44, 21); 

और भालू का उदाहरण कॉम्पैक्ट और पढ़ने में आसान है:

 string str = "         .    ,    ."; var result = str.ReplaceAll("").With("...").IgnoringCase(); 

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

आप इसे NuGet के साथ जल्दी से आज़मा सकते हैं।
और GitHub या CodePlex पर प्रोजेक्ट की मदद करें।