"पाठक" async के माध्यम से / सी # में इंतजार

अपने पिछले लेख में मैंने बताया कि कैसे async / प्रतीक्षित ऑपरेटरों का उपयोग करके "हो सकता है" मोनड व्यवहार को प्राप्त किया जाए। इस बार मैं उसी तकनीक का उपयोग करके एक और लोकप्रिय डिजाइन पैटर्न "रीडर मोनाड" को लागू करने का तरीका बताने जा रहा हूं।

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

class Config { public string Template; } public static async Task Main() { Console.WriteLine(await GreetGuys().Apply(new Config {Template = "Hi, {0}!"})); //(Hi, John!, Hi, Jose!) Console.WriteLine(await GreetGuys().Apply(new Config {Template = "¡Hola, {0}!" })); //(¡Hola, John!, ¡Hola, Jose!) } //These functions do not have any link to any instance of the Config class. public static async Reader<(string gJohn, string gJose)> GreetGuys() => (await Greet("John"), await Greet("Jose")); static async Reader<string> Greet(string name) => string.Format(await ExtractTemplate(), name); static async Reader<string> ExtractTemplate() => await Reader<string>.Read<Config>(c => c.Template); 

क्लासिक "रीडर"

सबसे पहले, आइए एक नज़र डालते हैं कि async / प्रतीक्षित ऑपरेटरों के बिना मोनाड को कैसे लागू किया जा सकता है:

 public class Config { public string Template; } public static class ClassicReader { public static void Main() { var greeter = GreetGuys(); Console.WriteLine(greeter.Apply(new Config{Template = "Hello, {0}"})); //(Hello, John, Hello, Jose) Console.WriteLine(greeter.Apply(new Config{Template = "¡Hola, {0}!" })); //(¡Hola, John!, ¡Hola, Jose!) } public static Reader<(string gJohn, string gJose), Config> GreetGuys() => from toJohn in Greet("John") from toJose in Greet("Jose") select (toJohn, toJose); //Without using the query notation the code would look like this: //Greet("John") // .SelectMany( // toJohn => Greet("Jose"), // (toJohn, toJose) => (toJohn, toJose)) public static Reader<string, Config> Greet(string name) => new Reader<string, Config>(cfg => string.Format(cfg.Template, name)); } 

(रीडर)

 public class Reader<T, TCtx> { private readonly Func<TCtx, T> _exec; public Reader(Func<TCtx, T> exec) => this._exec = exec; public T Apply(TCtx ctx) => this._exec(ctx); } public static class Reader { public static Reader<TJoin, TCtx> SelectMany<TIn, TOut, TCtx, TJoin>( this Reader<TIn, TCtx> source, Func<TIn, Reader<TOut, TCtx>> bind, Func<TIn, TOut, TJoin> join) => new Reader<TJoin, TCtx>(ctx => { var inValue = source.Apply(ctx); var outValue = bind(inValue).Apply(ctx); return join(inValue, outValue); }); } 

कोड काम करता है लेकिन यह C # डेवलपर्स के लिए स्वाभाविक नहीं लगता है। कोई आश्चर्य नहीं, क्योंकि मठ कार्यात्मक भाषाओं से आए हैं जहां समान कोड को अधिक संक्षिप्त तरीके से लिखा जा सकता है। हालांकि, क्लासिक कार्यान्वयन पैटर्न के सार को समझने में मदद करता है - कुछ कोड के तत्काल निष्पादन के बजाय इसे एक फ़ंक्शन में डाल दिया जाता है जिसे इसके संदर्भ तैयार होने पर बुलाया जाएगा।

 public static Reader<string, Config> Greet(string name) => new Reader<string, Config>(cfg => string.Format(cfg.Template, name)); //That is how the code would look like with explicit passing of context: //public static string Greet(string name, Config cfg) // => string.Format(cfg.Template, name); 

SelectMany कई ऐसे कार्यों को एक ही में जोड़ सकता है, इसलिए आप एक उप-दिनचर्या बना सकते हैं जिसका निष्पादन तब तक स्थगित रहेगा जब तक कि उसका संदर्भ लागू नहीं हो जाता। दूसरी ओर, वह दृष्टिकोण एसिंक्रोनस कोड लिखने से मिलता जुलता है जहां प्रोग्राम का निष्पादन रोक दिया जाता है अगर कुछ एसिंक्रोनस ऑपरेशन चल रहा हो। जब ऑपरेशन का परिणाम तैयार हो जाता है तो कार्यक्रम निष्पादन जारी रहेगा। एक धारणा यह है कि अतुल्यकालिक संचालन ( async / प्रतीक्षा ) के साथ काम करने के लिए डिज़ाइन किया गया C # बुनियादी ढांचा किसी भी तरह से "रीडर" मोनड के कार्यान्वयन में उपयोग किया जा सकता है और ... यह धारणा सही है!

Async "रीडर"

अपने पिछले लेख में मैंने प्रदर्शित किया था कि सामान्य रूप से वापस आये जाने वाले एस्किंट रिटर्न प्रकारों का उपयोग करके async / प्रतीक्षा ऑपरेटरों पर नियंत्रण कैसे प्राप्त करें। इस बार उसी तकनीक का इस्तेमाल किया जाएगा। आइए "पाठक" वर्ग से शुरू करते हैं जो अतुल्यकालिक संचालन के परिणामस्वरूप उपयोग किया जाएगा:

 [AsyncMethodBuilder(typeof(ReaderTaskMethodBuilder<>))] public class Reader<T> : INotifyCompletion, IReader { ... 

कक्षा में दो अलग-अलग जिम्मेदारियां हैं (सैद्धांतिक रूप से हम 2 कक्षाएं बना सकते हैं):

1. जब संदर्भ लागू किया जाता है तो कुछ मान निकालना एक संदर्भ बनता है
2. रीडर इंस्टेंस की एक लिंक की गई सूची का निर्माण जो एक कॉल पदानुक्रम पर एक संदर्भ वितरित करने के लिए उपयोग किया जाएगा।

प्रत्येक जिम्मेदारी के लिए हम एक अलग कंस्ट्रक्टर का उपयोग करेंगे:

 private readonly Func<object, T> _extractor; //1. Used to extract some value from a context public static Reader<T> Read<TCtx>(Func<TCtx, T> extractor) => new Reader<T>(ctx => extractor((TCtx)ctx)); private Reader(Func<object, T> exec) => this._extractor = exec; //2. Used by ReaderTaskMethodBuilder in a compiler generated code internal Reader() { } 

जब रीडर क्लास का एक उदाहरण प्रतीक्षा ऑपरेटर के तर्क के रूप में उपयोग किया जाता है, तो उदाहरण एक निरंतरता प्रतिनिधि को एक लिंक प्राप्त करेगा, जिसे केवल तब बुलाया जाना चाहिए जब कोई निष्पादन संदर्भ हल हो जाए और हम (संदर्भ से) कुछ डेटा निकाल सकें, जो कि होगा निरंतरता में उपयोग किया जाता है।

माता-पिता और बच्चे "पाठकों" के बीच संबंध बनाने के लिए आइए विधि बनाएँ:

 private IReader _child; internal void SetChild(IReader reader) { this._child = reader; if (this._ctx != null) { this._child.SetCtx(this._ctx); } } 

जिसे ReaderTaskMethodBuilder के अंदर बुलाया जाएगा:

 public class ReaderTaskMethodBuilder<T> { ... public void GenericAwaitOnCompleted<TAwaiter, TStateMachine>( ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { if (awaiter is IReader reader) { this.Task.SetChild(reader); } awaiter.OnCompleted(stateMachine.MoveNext); } public Reader<T> Task { get; } } 

SetChild विधि के अंदर हम SetCtx कहते हैं जो एक संदर्भ को पदानुक्रम तक प्रचारित करता है और यदि इसे परिभाषित किया जाता है तो एक एक्सट्रैक्टर को कॉल करता है:

 public void SetCtx(object ctx) { this._ctx = ctx; if (this._ctx != null) { this._child?.SetCtx(this._ctx); if (this._extractor != null) { this.SetResult(this._extractor(this._ctx)); } } } 

SetResult एक संदर्भ से निकाले गए मान को संग्रहीत करता है और एक निरंतरता कहता है:

 internal void SetResult(T result) { this._result = result; this.IsCompleted = true; this._continuation?.Invoke(); } 

उस स्थिति में जब एक रीडर इंस्टेंस में इनिशियलाइज़्ड "एक्सट्रैक्टर" नहीं होता है, तब SetResult को ReaderTaskMethodBuilder द्वारा कॉल किया जाना चाहिए, जब एक जेनरेट की गई स्टेट मशीन अपनी अंतिम स्थिति में जाती है।

विधि लागू करें बस SetCtx कहते हैं

 public Reader<T> Apply(object ctx) { this.SetCtx(ctx); return this; } 

आप जीथब पर सभी कोड पा सकते हैं ( यदि यह अभी भी अवरुद्ध नहीं है )

अब, मैं एक और अधिक यथार्थवादी उदाहरण दिखाना चाहता हूं कि कैसे एसिंक्स रीडर का उपयोग किया जा सकता है:

 public static class ReaderTest { public class Configuration { public readonly int DataBaseId; public readonly string GreetingTemplate; public readonly string NameFormat; public Configuration(int dataBaseId, string greetingTemplate, string nameFormat) { this.DataBaseId = dataBaseId; this.GreetingTemplate = greetingTemplate; this.NameFormat = nameFormat; } } public static async Task Main() { int[] ids = { 1, 2, 3 }; Configuration[] configurations = { new Configuration(100, "Congratulations, {0}! You won {1}$!", "{0} {1}"), new Configuration(100, "¡Felicidades, {0}! Ganaste {1} $", "{0}"), }; foreach (var configuration in configurations) { foreach (var userId in ids) { //The logic receives only a single explicit parameter - userId var logic = GetGreeting(userId); //The rest of parameters (database Id, templates) can be passed implicitly var greeting = await logic.Apply(configuration); Console.WriteLine(greeting) } } //Congratulations, John Smith! You won 110$! //Congratulations, Mary Louie! You won 30$! //Congratulations, Louis Slaughter! You won 47$! //¡Felicidades, John! Ganaste 110 $ //¡Felicidades, Mary! Ganaste 30 $ //¡Felicidades, Louis! Ganaste 47 $ } private static async Reader<string> GetGreeting(int userId) { var template = await Reader<string>.Read<Configuration>(cfg => cfg.GreetingTemplate); var fullName = await GetFullName(userId); var win = await GetWin(userId); return string.Format(template, fullName, win); } private static async Reader<string> GetFullName(int userId) { var template = await Reader<string>.Read<Configuration>(cfg => cfg.NameFormat); var firstName = await GetFirstName(userId); var lastName = await GetLastName(userId); return string.Format(template, firstName, lastName); } private static async Reader<string> GetFirstName(int userId) { var dataBase = await GetDataBase(); return await dataBase.GetFirstName(userId); } private static async Reader<string> GetLastName(int userId) { var dataBase = await GetDataBase(); return await dataBase.GetLastName(userId); } private static async Reader<int> GetWin(int userId) { var dataBase = await GetDataBase(); return await dataBase.GetWin(userId); } private static async Reader<Database> GetDataBase() { var dataBaseId = await Reader<int>.Read<Configuration>(cfg => cfg.DataBaseId); return Database.ConnectTo(dataBaseId); } } public class Database { public static Database ConnectTo(int id) { if (id == 100) { return new Database(); } throw new Exception("Wrong database"); } private Database() { } private static readonly (int Id, string FirstName, string LastName, int Win)[] Data = { (1, "John","Smith", 110), (2, "Mary","Louie", 30), (3, "Louis","Slaughter", 47), }; public async Task<string> GetFirstName(int id) { await Task.Delay(50); return Data.Single(i => i.Id == id).FirstName; } public async Task<string> GetLastName(int id) { await Task.Delay(50); return Data.Single(i => i.Id == id).LastName; } public async Task<int> GetWin(int id) { await Task.Delay(50); return Data.Single(i => i.Id == id).Win; } } 

कार्यक्रम कुछ उपयोगकर्ताओं के लिए अभिवादन दिखाता है लेकिन हम उनके नामों को पहले से नहीं जानते हैं क्योंकि हमारे पास सिर्फ उनका आईडी है, इसलिए हमें "डेटाबेस" से उस जानकारी को पढ़ना होगा। डेटाबेस से कनेक्ट करने के लिए हमें कुछ कनेक्शन आइडेंटिफ़ायर को जानना होगा और ग्रीटिंग बनाने के लिए हमें उसके टेम्पलेट की आवश्यकता होगी ... और सभी जानकारी पास की गई है जो कि async Reader को गर्त में डाल देगा।

Async "रीडर" के साथ निर्भरता इंजेक्शन

क्लासिक कार्यान्वयन के साथ तुलना में एसिंक्स रीडर में एक दोष है - हम एक प्रकार का पारित संदर्भ निर्दिष्ट नहीं कर सकते। यह सीमा इस तथ्य से आती है कि C # कंपाइलर को Async विधि बिल्डर क्लास में केवल एक सामान्य प्रकार के पैरामीटर की उम्मीद है (शायद यह भविष्य में तय हो जाएगा)।

दूसरी ओर, मुझे नहीं लगता कि यह महत्वपूर्ण है क्योंकि वास्तविक जीवन में शायद कुछ निर्भरता इंजेक्शन कंटेनर को एक संदर्भ के रूप में पारित किया जाएगा:

 public static class Reader { public static Reader<TService> GetService<TService>() => Reader<TService>.Read<IServiceProvider>(serviceProvider => (TService)serviceProvider .GetService(typeof(TService))); } 

 ... private static async Reader<string> Greet(string userName) { var service = await Reader.GetService<IGreater>(); return service.GreetUser(userName); } ... 

( यहां आप एक पूर्ण उदाहरण पा सकते हैं ... )

Async "हो सकता है" के विपरीत, जिसे मैंने किसी भी उत्पादन कोड में उपयोग करने की अनुशंसा नहीं की थी ( अंत में ब्लॉकों के साथ समस्या के कारण), मैं वास्तविक परियोजनाओं में async रीडर का उपयोग "(" के अलावा ") के प्रतिस्थापन के रूप में करने पर विचार करूंगा। पारंपरिक निर्भरता इंजेक्शन दृष्टिकोण (जब सभी निर्भरताएं एक क्लास कंस्ट्रक्टर में पारित हो जाती हैं) क्योंकि पाठक को कुछ फायदे हैं:

1. इंजेक्शन गुणों को संग्रहीत करने वाले वर्ग गुणों की कोई आवश्यकता नहीं है। वास्तव में कक्षाओं में कोई आवश्यकता नहीं है - सभी तर्क स्थिर तरीकों से लागू किए जा सकते हैं।
2. रीडर का उपयोग करना गैर अवरुद्ध कोड बनाने को प्रोत्साहित करेगा क्योंकि सभी विधियाँ अतुल्यकालिक होंगी और कुछ भी डेवलपर्स को इनपुट / आउटपुट संचालन के गैर अवरुद्ध संस्करणों का उपयोग करने से नहीं रोकेंगे।
3. कोड थोड़ा और अधिक "पठनीय" होगा - हर बार जब हम पाठक को कुछ विधि के परिणामस्वरूप देखते हैं तो हमें पता चलेगा कि इसके लिए कुछ निहित संदर्भ तक पहुंच की आवश्यकता है।
4. Async Reader प्रतिबिंब का उपयोग नहीं करता है।

बेशक पाठक का उपयोग करने के खिलाफ कुछ तर्क हो सकते हैं लेकिन फिर भी, इन लेखों का मुख्य उद्देश्य यह दिखाना है कि कैसे पैटर्न, जो शुरू में कार्यात्मक भाषाओं के लिए डिज़ाइन किए गए थे, को कोडिंग की अनिवार्य शैली के लिए अपनाया जा सकता है जिसे सरल माना जाता है अधिकांश लोगों द्वारा समझें।