"Reader" monad melalui async / tunggu di C #

Dalam artikel saya sebelumnya saya menjelaskan cara mencapai perilaku monad "Maybe" menggunakan operator async / wait . Kali ini saya akan menunjukkan bagaimana menerapkan pola desain populer lainnya "Reader Monad" menggunakan teknik yang sama.

Pola itu memungkinkan secara implisit melewati beberapa konteks ke beberapa fungsi tanpa menggunakan parameter fungsi atau objek global bersama dan itu dapat dianggap sebagai cara lain untuk mengimplementasikan injeksi ketergantungan. Sebagai contoh:

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); 

"Pembaca" klasik

Pertama, mari kita lihat bagaimana monad dapat diimplementasikan tanpa operator async / menunggu :

 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)); } 

(Pembaca)

 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); }); } 

Kode berfungsi tetapi tidak terlihat alami untuk pengembang C #. Tidak heran, karena monad berasal dari bahasa fungsional di mana kode yang sama dapat ditulis dengan cara yang lebih ringkas. Namun, implementasi klasik membantu mengecilkan esensi dari pola - alih-alih eksekusi segera dari beberapa kode itu dimasukkan ke dalam fungsi yang akan dipanggil ketika konteksnya siap.

 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 dapat menggabungkan beberapa fungsi tersebut menjadi satu, sehingga Anda dapat membuat sub-rutin yang pelaksanaannya akan ditunda sampai konteksnya diterapkan. Di sisi lain, pendekatan itu menyerupai penulisan kode asinkron di mana eksekusi program dihentikan jika beberapa operasi async berjalan. Ketika hasil operasi siap, eksekusi program akan dilanjutkan. Suatu asumsi muncul bahwa infrastruktur C # yang dirancang untuk bekerja dengan operasi asinkron ( async / menunggu ) entah bagaimana dapat digunakan dalam implementasi monad "Pembaca" dan ... asumsi itu benar!

"Pembaca" Async

Dalam artikel saya sebelumnya, saya mendemonstrasikan cara mendapatkan kontrol atas operator async / menunggu menggunakan tipe pengembalian async Generalized . Teknik yang sama akan digunakan saat ini. Mari kita mulai dengan kelas "Pembaca" yang akan digunakan sebagai jenis hasil operasi asinkron:

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

Kelas memiliki dua tanggung jawab yang berbeda (secara teoritis kita dapat membuat 2 kelas):

1. Mengekstraksi beberapa nilai membentuk konteks ketika konteks diterapkan
2. Pembuatan daftar instance Reader yang ditautkan yang akan digunakan untuk mendistribusikan konteks melalui hierarki panggilan.

Untuk setiap tanggung jawab, kami akan menggunakan konstruktor terpisah:

 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() { } 

Ketika instance kelas Reader digunakan sebagai argumen dari operator yang menunggu instance akan menerima tautan ke delegasi lanjutan yang harus dipanggil hanya ketika konteks eksekusi diselesaikan dan kami dapat mengekstrak (dari konteks) beberapa data yang akan digunakan dalam kelanjutan.

Untuk membuat koneksi antara "pembaca" induk dan anak, mari kita buat metode ini:

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

yang akan dipanggil di dalam 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; } } 

Di dalam metode SetChild kita memanggil SetCtx yang menyebarkan konteks ke hierarki dan memanggil extractor jika didefinisikan:

 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 menyimpan nilai yang diekstraksi dari konteks dan memanggil kelanjutan:

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

Dalam kasus ketika instance Reader tidak memiliki "extractor" yang diinisialisasi, maka SetResult seharusnya dipanggil oleh ReaderTaskMethodBuilder ketika mesin state yang dihasilkan masuk ke status akhir.

Terapkan metode panggil saja SetCtx

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

Anda dapat menemukan semua kode di github ( jika masih belum diblokir )

Sekarang, saya ingin menunjukkan contoh yang lebih realistis tentang bagaimana Async Reader dapat digunakan:

 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; } } 

Program ini menunjukkan salam untuk beberapa pengguna tetapi kami tidak tahu nama mereka sebelumnya karena kami hanya memiliki id mereka, jadi kami perlu membaca informasi itu dari "database". Untuk terhubung ke basis data, kita perlu mengetahui beberapa pengenal koneksi dan untuk membuat salam, kita memerlukan templatnya dan ... semua informasi dilewatkan secara implisit melalui Pembaca async.

Ketergantungan Injeksi dengan Async "Reader"

Dibandingkan dengan implementasi klasik, pembaca async memiliki kekurangan - kita tidak dapat menentukan jenis konteks yang diteruskan. Keterbatasan ini berasal dari fakta bahwa C # compiler mengharapkan hanya satu tipe parameter generik dalam kelas metode async builder (mungkin akan diperbaiki di masa depan).

Di sisi lain, saya tidak berpikir itu penting karena dalam kehidupan nyata kemungkinan besar beberapa wadah injeksi ketergantungan akan diberikan sebagai konteks:

 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); } ... 

(di sini Anda dapat menemukan contoh lengkap ... )

Tidak seperti async "Maybe" , yang saya tidak rekomendasikan untuk digunakan dalam kode produksi apa pun (karena masalah dengan akhirnya blok), saya akan mempertimbangkan untuk menggunakan Async Reader dalam proyek nyata sebagai pengganti (atau "selain") pendekatan injeksi ketergantungan tradisional (ketika semua dependensi dilewatkan ke konstruktor kelas) karena Pembaca memiliki beberapa keuntungan:

1. Tidak perlu di properti kelas yang menyimpan tautan ke sumber daya yang disuntikkan. Sebenarnya tidak perlu di kelas sama sekali - semua logika dapat diimplementasikan dalam metode statis.
2. Menggunakan Pembaca akan mendorong pembuatan kode non-pemblokiran karena semua metode akan tidak sinkron dan tidak ada yang akan mencegah pengembang menggunakan versi operasi input / output yang tidak menghalangi.
3. Kode akan sedikit lebih "dapat dibaca" - setiap kali kita melihat Pembaca sebagai jenis hasil dari beberapa metode kita akan tahu bahwa itu memerlukan akses ke beberapa konteks implisit.
4. Pembaca async tidak menggunakan refleksi.

Tentu saja mungkin ada beberapa argumen yang menentang penggunaan Pembaca tetapi bagaimanapun, tujuan utama dari artikel ini adalah untuk menunjukkan bagaimana pola, yang awalnya dirancang untuk bahasa fungsional, dapat diadopsi ke gaya imperatif pengkodean yang diyakini lebih mudah untuk dimengerti oleh kebanyakan orang.