कोड जीवित और मृत है। भाग तीन पाठ के रूप में कोड

कार्यक्रम में साथ देने के लिए, आपको कोड को पढ़ना होगा, और इसे करना जितना आसान होगा, उतना ही यह एक प्राकृतिक भाषा जैसा दिखता है - फिर आप जल्दी से खुदाई करते हैं और मुख्य बात पर ध्यान केंद्रित करते हैं।

पिछले दो लेखों में, मैंने दिखाया कि ध्यान से चयनित शब्द जो लिखा गया है, उसके सार को बेहतर ढंग से समझने में मदद करता है, लेकिन केवल उनके बारे में सोचना पर्याप्त नहीं है, क्योंकि प्रत्येक शब्द दो रूपों में मौजूद है: अपने आप में और एक वाक्य के हिस्से के रूप में। जब तक हम इसे Thread.CurrentThread के संदर्भ में नहीं पढ़ते हैं, तब तक दोहराए जाने वाले Thread.CurrentThread अभी तक दोहराया नहीं जाता है।

इस प्रकार, नोट्स और सरल धुनों द्वारा निर्देशित, अब हम देखेंगे कि संगीत क्या है।

सामग्री की चक्र तालिका

1. वस्तुएं
2. क्रिया और गुण
3. पाठ के रूप में कोड

पाठ के रूप में कोड

अधिकांश धाराप्रवाह इंटरफेस को आंतरिक के बजाय बाहरी पर जोर देने के साथ डिज़ाइन किया गया है, इसलिए वे पढ़ने में बहुत आसान हैं। बेशक, मुफ्त में नहीं: सामग्री एक अर्थ में कमजोर है। तो, चलिए FluentAssertions हैं, FluentAssertions पैकेज में FluentAssertions लिख सकते हैं: (2 + 2).Should().Be(4, because: "2 + 2 is 4!") , और, पढ़ने के सापेक्ष, because सुरुचिपूर्ण दिखता है, लेकिन Be() अंदर Be() बल्कि, error या error । पैरामीटर पैरामीटर errorMessage ।

मेरी राय में, ऐसी छूट महत्वपूर्ण नहीं हैं। जब हम इस बात से सहमत होते हैं कि कोड एक पाठ है, तो इसके घटक स्वयं से संबंधित हैं: वे अब किसी प्रकार के सार्वभौमिक "ईथर" का हिस्सा हैं ।

मैं उदाहरणों से दिखाऊंगा कि इस तरह के विचार कैसे अनुभव बन जाते हैं।

Interlocked

मैं आपको Interlocked मामले की याद दिलाता हूं, जिसे हमने Interlocked.CompareExchange(ref x, newX, oldX) से Interlocked.CompareExchange(ref x, newX, oldX) Atomically.Change(ref x, from: oldX, to: newX) में तरीकों और मापदंडों के स्पष्ट नामों का उपयोग करते हुए किया है।

ExceptWith

टाइप ISet<> में एक विधि है, जिसे ExceptWith कहा जाता है। यदि आप items.ExceptWith(other) तरह एक कॉल को items.ExceptWith(other) हैं। items.ExceptWith(other) , आपको तुरंत महसूस नहीं होगा कि क्या हो रहा है। लेकिन आपको बस लिखना होगा: items.Exclude(other) , जैसा कि सब कुछ जगह में आता है।

GetValueOrDefault

Nullable<T> साथ काम करते Nullable<T> x.Value को कॉल करने पर अपवाद null हो जाएगा यदि x null । यदि आपको अभी भी Value प्राप्त करने की आवश्यकता है, तो x.GetValueOrDefault उपयोग x.GetValueOrDefault : यह या तो Value या डिफ़ॉल्ट मान है। बोझिल।

अभिव्यक्ति "या x, या डिफ़ॉल्ट मान" लघु और सुरुचिपूर्ण x.OrDefault मेल खाती है।

 int? x = null; var a = x.GetValueOrDefault(); // ,  .  . var b = x.OrDefault(); //  —  ,   . var c = x.Or(10); //     . 

OrDefault साथ और Or फिर एक बात याद रखने लायक है: ऑपरेटर के साथ काम करते समय .? आप x?.IsEnabled.Or(false) जैसा कुछ भी नहीं लिख सकते हैं।

जब IEnumerable<T> साथ काम करने पर टेम्पलेट लागू किया जा सकता है:

 IEnumerable<int> numbers = null; // . var x = numbers ?? Enumerable.Empty<int>(); //   . var x = numbers.OrEmpty(); 

Math.Min और Math.Max

Or साथ एक विचार को संख्यात्मक प्रकारों में विकसित किया जा सकता है। मान लीजिए कि आप a और b से अधिकतम संख्या लेना चाहते हैं। फिर हम लिखते हैं: Math.Max(a, b) या a > b ? a : b a > b ? a : b । दोनों विकल्प काफी परिचित हैं, लेकिन, फिर भी, एक प्राकृतिक भाषा की तरह नहीं दिखते हैं।

आप इसे बदल सकते हैं: a.Or(b).IfLess() - a या b यदि कम a तो ले लो । ऐसी स्थितियों के लिए उपयुक्त:

 Creature creature = ...; int damage = ...; //   . creature.Health = Math.Max(creature.Health - damage, 0); // Fluent. creature.Health = (creature.Health - damage).Or(0).IfGreater(); //   : creature.Health = (creature.Health - damage).ButNotLess(than: 0); 

string.Join

कभी-कभी आपको एक अनुक्रम को एक स्ट्रिंग में इकट्ठा करने की आवश्यकता होती है, तत्वों को एक स्थान या अल्पविराम के साथ अलग करना। ऐसा करने के लिए, string.Join उपयोग करें। उदाहरण के लिए, string.Join(", ", new [] { 1, 2, 3 }); // "1, 2, 3". करें, जैसे: string.Join(", ", new [] { 1, 2, 3 }); // "1, 2, 3". string.Join(", ", new [] { 1, 2, 3 }); // "1, 2, 3". ।

एक साधारण "कॉमा संख्या को विभाजित करें" अचानक "सूची से प्रत्येक नंबर पर एक कॉमा संलग्न करें " हो सकता है - यह निश्चित रूप से पाठ के रूप में एक कोड नहीं है।

 var numbers = new [] { 1, 2, 3 }; // ""    —  . var x = string.Join(", ", numbers); //    — ! var x = numbers.Separated(with: ", "); 

Regex

हालांकि, string.Join को कभी-कभी गलत तरीके से और अन्य उद्देश्यों के लिए उपयोग करने की तुलना में string.Join काफी हानिरहित है। जहां आप सरल, पठनीय पाठ के साथ प्राप्त कर सकते हैं, किसी कारण से एक अतिव्याप्त प्रविष्टि पसंद की जाती है।

आइए एक सरल से शुरू करें - यह निर्धारित करते हुए कि एक स्ट्रिंग संख्याओं के एक समूह का प्रतिनिधित्व करती है:

 string id = ...; // ,  . var x = Regex.IsMatch(id, "^[0-9]*$"); // . var x = id.All(x => x.IsDigit()); // ! var x = id.IsNumer(); 

एक और मामला यह पता लगाना है कि क्या अनुक्रम से स्ट्रिंग में कम से कम एक वर्ण है:

 string text = ...; //   . var x = Regex.IsMatch(text, @"["<>[]'"); //   . ( .) var x = text.ContainsAnyOf('"', '<', '>', '[', ']', '\''); //  . var x = text.ContainsAny(charOf: @"["<>[]'"); 

जितना अधिक जटिल कार्य, उतना ही कठिन समाधान "पैटर्न": "Hello World" "HelloWorld" रिकॉर्ड को "Hello World" विभाजित करने के लिए, एक सरल एल्गोरिथ्म के बजाय कोई व्यक्ति एक राक्षस चाहता था:

 string text = ...; //   -   . var x = Regex.Replace(text, "([az](?=[AZ])|[AZ](?=[AZ][az]))", "$1 "); //  . var x = text.PascalCaseWords().Separated(with: " "); //   . var x = text.AsWords(eachStartsWith: x => x.IsUpper()).Separated(with: " "); 

निस्संदेह, नियमित अभिव्यक्ति प्रभावी और सार्वभौमिक हैं, लेकिन मैं समझना चाहता हूं कि पहली नजर में क्या हो रहा है।

Substring Remove और Remove

ऐसा होता है कि आपको शुरुआत या अंत से लाइन से कुछ हिस्सा निकालने की आवश्यकता होती है, उदाहरण के लिए, path - विस्तार .txt , यदि कोई हो।

 string path = ...; //    . var x = path.EndsWith(".txt") ? path.Remove(path.Length - "txt".Length) : path; //   . var x = path.Without(".exe").AtEnd; 

फिर से, कार्रवाई और एल्गोरिथ्म चले गए थे , और अंत में .exe एक्सटेंशन के बिना एक सरल रेखा छोड़ दी गई थी ।

चूँकि Without विधि के एक निश्चित WithoutExpression वापस आ जाना चाहिए, वे दूसरे के लिए भीख माँगते हैं: path.Without("_").AtStart और path.Without("Something").Anywhere । यह भी दिलचस्प है कि एक ही शब्द के साथ एक और अभिव्यक्ति का निर्माण किया जा सकता है: name.Without(charAt: 1) - सूचकांक 1 पर चरित्र को हटाता है और एक नई लाइन देता है (क्रमपरिवर्तन की गणना में उपयोगी)। और पठनीय भी!

Type.GetMethods

प्रतिबिंब का उपयोग करके एक निश्चित प्रकार के तरीके प्राप्त करने के लिए, निम्न का उपयोग करें:

 Type type = ...; //   `Get` ,   `|`.     . var x = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); // ,  . `Or`   , . var x = type.Methods(_ => _.Instance.Public.Or.NonPublic); 

(वही GetFields और GetFields लिए जाता है।)

Directory.Copy

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

"डी: \ स्रोत 'से' डी: \ लक्ष्य 'तक सभी फाइलें "D:\\Source".AsDirectory().Copy().Files.To("D:\\Target") कोड "D:\\Source".AsDirectory().Copy().Files.To("D:\\Target") । AsDirectory() - string से DirectoryInfo देता है, और Copy() - CopyExpression का एक उदाहरण बनाता है जो अभिव्यक्ति के निर्माण के लिए एक अद्वितीय API का वर्णन करता है (आप Copy().Files.Files नहीं कर सकते हैं Copy().Files.Files उदाहरण के लिए Copy().Files.Files )। फिर अवसर सभी फ़ाइलों को कॉपी करने के लिए खुलता है, लेकिन कुछ: Copy().Files.Where(x => x.IsNotEmpty) ।

GetOrderById

दूसरे लेख में, मैंने लिखा कि IUsersRepository.GetUser(int id) बेमानी है, और बेहतर है, IUsersRepository.User(int id) । तदनुसार, एक समान IOrdersRepository हमारे पास GetOrderById(int id) , लेकिन Order(int id) । हालांकि, एक अन्य उदाहरण में, यह सुझाव दिया गया था कि ऐसी रिपॉजिटरी के वेरिएबल को _ordersRepository रिपॉजिटरी नहीं, बल्कि केवल _orders कहा जाता है।

दोनों परिवर्तन अपने आप में अच्छे हैं, लेकिन वे पढ़ने के संदर्भ में एक साथ नहीं जोड़ते हैं: कॉलिंग _orders.Order(id) दिखता है। यह संभव होगा कि _orders.Get(id) , लेकिन आदेश विफल होते हैं, हम केवल उसी को निर्दिष्ट करना चाहते हैं जिसके पास ऐसा पहचानकर्ता है । एक है कि One , इसलिए:

 IOrdersRepository orders = ...; int id = ...; //   . var x = orders.GetOrderById(id); //      : var x = orders.Order(id); //     ,    . var x = orders.One(id); //    : var x = orders.One(with: id); 

GetOrders

IOrdersRepository जैसी वस्तुओं में, अन्य विधियाँ अक्सर पाई जाती हैं: AddOrder , RemoveOrder , GetOrders । पहले दो पुनरावृत्तियाँ चली जाती हैं, और Add और Remove प्राप्त की जाती हैं (इसी प्रविष्टियों के साथ _orders.Add(order) और _orders.Remove(order) )। GetOrders साथ GetOrders Orders थोड़ा नाम बदलना कठिन है। आइए देखें:

 IOrdersRepository orders = ...; //   . var x = orders.GetOrders(); //  `Get`,  . var x = orders.Orders(); // ! var x = orders.All(); 

यह ध्यान दिया जाना चाहिए कि पुराने _ordersRepository GetOrders या GetOrderById कॉल में repetitions इतने ध्यान देने योग्य नहीं हैं, क्योंकि हम रिपॉजिटरी के साथ काम कर रहे हैं!

One जैसे नाम, All कई इंटरफेस के लिए उपयुक्त हैं जो कई का प्रतिनिधित्व करते हैं। कहो, GitHub API के प्रसिद्ध कार्यान्वयन में - octokit - सभी उपयोगकर्ता रिपॉजिटरी प्राप्त करना gitHub.Repository.GetAllForUser("John") तरह दिखता है, हालांकि यह अधिक तार्किक है - gitHub.Users.One("John").Repositories.All । इस मामले में, एक रिपॉजिटरी प्राप्त करना, क्रमशः gitHub.Repository.Get("John", "Repo") बजाय स्पष्ट gitHub.Users.One("John").Repositories.One("Repo") । दूसरा मामला लंबा दिखता है, लेकिन यह आंतरिक रूप से सुसंगत है और मंच को दर्शाता है। इसके अलावा, विस्तार विधियों का उपयोग करते हुए, इसे gitHub.User("John").Repository("Repo") छोटा किया जा सकता है gitHub.User("John").Repository("Repo") ।

Dictionary.TryGetValue

शब्दकोश से मूल्यों को प्राप्त करना कई परिदृश्यों में विभाजित है जो केवल कुंजी के न होने पर किए जाने वाले कार्यों में भिन्न होते हैं:

• एक त्रुटि फेंक ( dictionary[key] );
• डिफ़ॉल्ट मान लौटाएं (लागू नहीं किया गया, लेकिन अक्सर TryGetValue या TryGetValue );
• कुछ और लौटाएं (लागू नहीं किया गया, लेकिन मुझे GetValueOrOther उम्मीद है);
• शब्दकोश में निर्दिष्ट मान लिखें और इसे वापस करें (लागू नहीं किया गया, लेकिन GetOrAdd का GetOrAdd )।

इस बिंदु पर अभिव्यक्तियाँ " कुछ X, या Y लेती हैं यदि X नहीं है ।" इसके अलावा, जैसा कि _ordersRepository के मामले में, हम डिक्शनरी वैरिएबल को items itemsDictionary नहीं, बल्कि items itemsDictionary ।

फिर "कुछ एक्स" भाग के लिए , फॉर्म items.One(withKey: X) का एक कॉल। एक items.One(withKey: X) आदर्श है, चार items.One(withKey: X) साथ एक संरचना लौटाता है:

 Dictionary<int, Item> items = ...; int id = ...; //  ,   : var x = items.GetValueOrDefault(id); var x = items[id]; var x = items.GetOrAdd(id, () => new Item()); //    : var x = items.One(with: id).OrDefault(); var x = items.One(with: id).Or(Item.Empty); var x = items.One(with: id).OrThrow(withMessage: $"Couldn't find item with '{id}' id."); var x = items.One(with: id).OrNew(() => new Item()); 

Assembly.GetTypes

आइए देखें कि विधानसभा में T सभी मौजूदा उदाहरणों को कैसे बनाया जाए:

 // . var x = Assembly .GetAssembly(typeof(T)) .GetTypes() .Where(...) .Select(Activator.CreateInstance); // "" . var x = TypesHelper.GetAllInstancesOf<T>(); // . var x = Instances.Of<T>(); 

इस प्रकार, कभी-कभी, एक स्थिर वर्ग का नाम एक अभिव्यक्ति की शुरुआत है ।

कुछ ऐसा ही NUnit में पाया जा सकता है: Assert.That(2 + 2, Is.EqualTo(4)) - Is और एक आत्मनिर्भर प्रकार के रूप में कल्पना नहीं की गई थी।

Argument.ThrowIfNull

अब आइए एक नज़र डालें पूर्ववर्ती जाँच पर:

 //  . Argument.ThrowIfNull(x); Guard.CheckAgainstNull(x); // . x.Should().BeNotNull(); // ,  ...  ? Ensure(that: x).NotNull(); 

Ensure.NotNull(argument) - अच्छा है, लेकिन काफी अंग्रेजी नहीं है। एक और बात Ensure(that: x).NotNull() ऊपर लिखा गया है। यदि केवल वहाँ ...

वैसे, आप कर सकते हैं! हम Contract.Ensure(that: argument).IsNotNull() लिखते हैं। Contract.Ensure(that: argument).IsNotNull() और using static Contract के प्रकार को आयात करें। अतः सभी प्रकार के Ensure(that: type).Implements<T>() , Ensure(that: number).InRange(from: 5, to: 10) , आदि Ensure(that: number).InRange(from: 5, to: 10) होते हैं।

स्थैतिक आयात का विचार कई दरवाजे खोलता है। items.Remove(x) बजाय: के लिए एक सुंदर उदाहरण। items.Remove(x) Remove(x, from: items) लिखें। लेकिन जिज्ञासु उन कार्यों और गुणों की कमी है जो फ़ंक्शंस लौटाते हैं।

 IItems items = ...; // . var x = items.All(where: x => x.IsWeapon); //  . // `ItemsThatAre.Weapons`  `Predicate<bool>`. var x = items.All(ItemsThatAre.Weapons); // `using static`  !  . var x = items.All(Weapons); 

विदेशी Find

C # 7.1 और उच्चतर में, आप Find(1, @in: items) , बल्कि Find(1, in items) लिख सकते हैं, जहाँ Find को Find<T>(T item, in IEnumerable<T> items) रूप में परिभाषित किया गया है। यह उदाहरण अव्यावहारिक है, लेकिन दिखाता है कि पठनीयता के संघर्ष में सभी साधन अच्छे हैं।

कुल मिलाकर

इस भाग में, मैंने कोड पठनीयता के साथ काम करने के कई तरीकों को देखा। उन सभी को सामान्यीकृत किया जा सकता है:

• अभिव्यक्ति के भाग के रूप में नामित पैरामीटर है Should().Be(4, because: "") , Atomically.Change(ref x, from: oldX, to: newX) ।
• तकनीकी विवरणों के बजाय एक सरल नाम Separated(with: ", ") , Exclude ।
• चर के भाग के रूप में विधि x.OrDefault() , x.Or(b).IfLess() , orders.One(with: id) , orders.All ।
• अभिव्यक्ति के भाग के रूप में विधि path.Without(".exe").AtEnd ।
• अभिव्यक्ति के भाग के रूप में प्रकार Instances.Of , Is.EqualTo ।
• अभिव्यक्ति के भाग के रूप में विधि ( using static ) यह Ensure(that: x) , items.All(Weapons) ।

इस प्रकार, बाह्य और चिंतन को सामने लाया जाता है। सबसे पहले यह सोचा जाता है, और फिर इसके विशिष्ट अवतारों को सोचा जाता है, इतना महत्वपूर्ण नहीं, जब तक कि कोड को पाठ के रूप में पढ़ा जाता है। यह इस प्रकार है कि न्यायाधीश को भाषा का उतना स्वाद नहीं है - वह item.GetValueOrDefault बीच का अंतर निर्धारित करता है। item.GetValueOrDefault और item.OrDefault ।

उपसंहार

जो बेहतर है, स्पष्ट है, लेकिन काम करने का तरीका नहीं है, या काम नहीं कर रहा है, लेकिन समझ से बाहर है? फर्नीचर और कमरों के बिना एक बर्फ-सफेद महल या लुई XIV की शैली में सोफे के साथ एक शेड? इंजन के बिना एक लक्जरी नौका या एक क्वांटम कंप्यूटर के साथ एक कराहना बजरा जो कोई भी उपयोग नहीं कर सकता है?

ध्रुवीय उत्तर फिट नहीं है, लेकिन "कहीं बीच में" भी।

मेरी राय में, दोनों अवधारणाएं अटूट हैं: ध्यान से एक किताब के लिए एक कवर चुनना, हम संदेह से पाठ में त्रुटियों को देखते हैं, और इसके विपरीत। मैं नहीं चाहूंगा कि बीटल्स कम-गुणवत्ता वाला संगीत बजाएं , लेकिन उन्हें भी MusicHelper कहा जाना चाहिए ।

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

ध्यान देने के लिए आप सभी का धन्यवाद!

संदर्भ

अधिक उदाहरण देखने में दिलचस्पी रखने वाले किसी भी व्यक्ति को मेरे GitHub पर देखा जा सकता है, उदाहरण के लिए, Pocket.Common लाइब्रेरी में। (दुनिया भर में और सार्वभौमिक उपयोग के लिए नहीं)