<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ugur Can on Medium]]></title>
        <description><![CDATA[Stories by Ugur Can on Medium]]></description>
        <link>https://medium.com/@mugrcn?source=rss-81486897c83f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*isiUU6yQLgTEFPdGoQRpdQ.png</url>
            <title>Stories by Ugur Can on Medium</title>
            <link>https://medium.com/@mugrcn?source=rss-81486897c83f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 18:05:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mugrcn/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[C# da Asenkron Programlama ve Threading Arasındaki Farklar]]></title>
            <link>https://medium.com/@mugrcn/c-da-asenkron-programlama-ve-threading-aras%C4%B1ndaki-farklar-26e1726c806b?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/26e1726c806b</guid>
            <category><![CDATA[asynchronous-programming]]></category>
            <category><![CDATA[difference]]></category>
            <category><![CDATA[async]]></category>
            <category><![CDATA[multithreading]]></category>
            <category><![CDATA[dotnet-core]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Tue, 14 Oct 2025 21:42:47 GMT</pubDate>
            <atom:updated>2025-10-14T21:42:47.189Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu makalede, paralel programlamanın iki anahtar tekniği arasındaki farkları öğreneceğiz — Asenkron programlama ve Multithreading. Daha da önemlisi iki tekniğin kullanım senaryoları üzerinde duracağız.</p><p>.NET’de Asenkron programlama ve Multithreading hakkında hızlı bir hatırlatma ile başlayalım.</p><h3>Asenkron Programlama</h3><p>Asenkron programlama işlemlerin ana program akışından bağımsız bir şekilde koşulduğu bir paralel programlama biçimidir.</p><p><strong>Asenkron programlamayı, program içerisinde bloklayan bir işlem ile karşılaşıp sonucu beklemeden program akışının devam etmesini istediğimizde kullanırız. </strong>Bu sayede taskların aynı anda koşmasını sağlamış oluruz.</p><p>C# da asenkron programlamayı async ve await keyword ‘leri kullanarak sağlarız. Bununla ilgili daha detaylı bilgiyi <a href="https://medium.com/@mugrcn/asp-net-core-asenkron-programlama-async-await-c660f0611172"><strong>ASP.NET Core Asenkron Programlama(Async &amp; Await)</strong></a> makalesinde bulabilirsiniz.</p><h3>Multithreading</h3><p>Bilgisayar biliminde “thread” (iş parçacığı), bir program içinde kesintisiz şekilde ilerleyen tek bir kontrol akışını ifade eder. Multithreading, işlemcinin birden fazla işlemi cncurrent yürütebilmek için birden fazla iş parçacığını kullanması tekniğidir.</p><p><strong>Multithreading</strong> tekniğini genellikle, çok çekirdekli işlemcilerin gücünden en iyi şekilde yararlanmak ve her çekirdeğin bağımsız olarak çalışmasını sağlamak istediğimiz durumlarda kullanırız.</p><p>C# da System.Threading namespace’i uygulamamızda multithreading tekniğini gerçekleştirmek için sınıflar ve interface’ler mevcuttur.</p><h3>Asenkron Programlama vs Multithreading</h3><p>Multithreading ve asenkron programlama aynı şeymiş gibi bir yanlış anlama var. <strong>Asenkron programlama, görevlerin (Task’lerin) zamandan bağımsız olarak sıralı bir şekilde yürütülmesiyle ilgilenirken, multithreading ise birden fazla thread’in aynı anda paralel olarak çalışmasıyla ilgilidir.</strong></p><p>Multithreading, programlamada asenkron çalışmanın bir yoludur; ancak tek thread’li asenkron görevler de oluşturabiliriz.</p><p>Bu farkı anlamanın en iyi yolu, bir örnek üzerinden görmektir.</p><h3>Async Kod Örneği</h3><p>Bir action içerisindeki birden fazla asenkron işlemi inceleyelim:</p><pre>public static async Task FirstAsync()<br>{<br>    Console.WriteLine(&quot;First Async Method on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>    await Task.Delay(1000);<br>    Console.WriteLine(&quot;First Async Method Continuation on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>}<br><br>public static async Task SecondAsync()<br>{<br>    Console.WriteLine(&quot;Second Async Method on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>    await Task.Delay(1000);<br>    Console.WriteLine(&quot;Second Async Method Continuation on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>}<br><br>public static async Task ThirdAsync()<br>{<br>    Console.WriteLine(&quot;Third Async Method on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>    await Task.Delay(1000);<br>    Console.WriteLine(&quot;Third Async Method Continuation on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>}</pre><p>Tüm asenkron metodların içinde, başlangıçda metodun kullandığı thread id’yi console’a yazdıran kod ekledik. Daha sonra bir saniye süren bir işi simule etmek için delay ekledik, en son da, tekrardan thread id’yi console’a yazdıran kod ekledik.</p><p>Şimdi de, bu metodları çalıştıran başka bir metod ekleyelim:</p><pre>public static async Task ExecuteAsyncFunctions()<br>{<br>    var firstAsync = FirstAsync();<br>    var secondAsync = SecondAsync();<br>    var thirdAsync = ThirdAsync();<br><br>    await Task.WhenAll(firstAsync, secondAsync, thirdAsync);<br>}</pre><p>Son olarak Main metodu güncelleyelim:</p><pre>static async Task Main(string[] args)<br>{      <br>    await ExecuteAsyncFunctions();<br>}</pre><p>Şimdi uygulamayı çalıştırıp çıktıyı inceleyelim:</p><pre>First Async Method on Thread with Id: 1<br>Second Async Method on Thread with Id: 1<br>Third Async Method on Thread with Id: 1<br>Third Async Method Continuation on Thread with Id: 4<br>Second Async Method Continuation on Thread with Id: 8<br>First Async Method Continuation on Thread with Id: 11</pre><p>Gördüğünüz gibi tüm thread’ler 1 numaralı aynı thread ile başlıyorlar. Ama daha sonra farklı thread’ler ile çalışmalarını sürdürüyorlar (4, 8, 11).</p><p>Peki, neden böyle oluyor?</p><p>Çünkü, FirstAsync metodundaki thread ne zaman ki await yapmaya başlıyor, thread metoddan serbest kalıyor ve thread pool’a tekrar dönüyor. İşlem tamamlanıp devam etmeye başlayınca, thread pool’dan yeni bir thread atanıyor. Aynı durum SecondAsync ve ThirdAsync metodları için de tekrarlanıyor.</p><h3>Multithreading Kod Örneği</h3><p>Aynı ortamı multithreadin için de gerçekleştirelim:</p><pre>public class Multithreading<br>{<br>    public void FirstMethod()<br>    {<br>        Console.WriteLine(&quot;First Method on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>        Thread.Sleep(1000);<br>        Console.WriteLine(&quot;First Method Continuation on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>    }<br><br>    public void SecondMethod()<br>    {<br>        Console.WriteLine(&quot;Second Method on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>        Thread.Sleep(1000);<br>        Console.WriteLine(&quot;Second Method Continuation on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>    }<br><br>    public void ThirdMethod()<br>    {<br>        Console.WriteLine(&quot;Third Method on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>        Thread.Sleep(1000);<br>        Console.WriteLine(&quot;Third Method Continuation on Thread with Id: &quot; + Thread.CurrentThread.ManagedThreadId);<br>    }<br>}</pre><p>Tabi bir de bu metodları çalıştırmamız lazım:</p><pre>public void ExecuteMultithreading()<br>{<br>    Thread t1 = new Thread(new ThreadStart(FirstMethod));<br>    Thread t2 = new Thread(new ThreadStart(SecondMethod));<br>    Thread t3 = new Thread(new ThreadStart(ThirdMethod));<br><br>    t1.Start();<br>    t2.Start();<br>    t3.Start();<br>}</pre><p>Son olarak Main metodu düzenleyelim:</p><pre>static async Task Main(string[] args)<br>{      <br>    await ExecuteAsyncFunctions();<br><br>    Console.WriteLine();<br>          <br>    Multithreading multithreading = new Multithreading();<br>    multithreading.ExecuteMultithreading();<br>}</pre><p>Şimdi de oluşan çıktıya bakıp birbirlerinden ne kadar farklı çalıştıklarını inceleyelim:</p><pre>First Async Method on Thread with Id: 1<br>Second Async Method on Thread with Id: 1<br>Third Async Method on Thread with Id: 1<br>Third Async Method Continuation on Thread with Id: 4<br>Second Async Method Continuation on Thread with Id: 8<br>First Async Method Continuation on Thread with Id: 11<br><br>First Multithreading Method on Thread with Id: 14<br>Second Multithreading Method on Thread with Id: 15<br>Third Multithreading Method on Thread with Id: 16<br>Second Multithreading Method Continuation on Thread with Id: 15<br>First Multithreading Method Continuation on Thread with Id: 14<br>Third Multithreading Method Continuation on Thread with Id: 16</pre><p>Beklediğimiz gibi multithread methodların çalışması beklediğimiz gibi sonuçlandı. Yani asenkron metodlar gibi davranmayıp, wait sonrası aynı threadleri kullanmaya devam ettiler.</p><p>Bu örnekten de görüldüğü üzere asıl fark — Multithreading, birden fazla thread ile (“worker” olarak da adlandırılır) işlemleri yürütmeye yarayan bir programlama tekniğidir. Bu yaklaşımda farklı iş parçacıkları kullanılır ve her biri işi bitene kadar bloke edilir. Asenkron programlama ise birden fazla görevin (task) eşzamanlı yürütülmesidir; burada, bir metotta await ifadesine gelindiğinde o göreve atanmış thread geri dönüp thread pool’a bırakılır.</p><h3>Kullanım Senaryoları (Use Cases)</h3><p>Multithreading ve asenkron programlamanın farkını anladığımıza göre kullanım senaryolarını inceleyebiliriz.</p><p>Metodlar içerisinde bloklanan kısımlar varsa asenkron programlama kullanmalıyız. Sabit sayıda bir thread pool veya dikey ölçekleme ihtiyacımız varsa asenkron programlama kullanırız.</p><p>Birbirinden bağımsız görevler yapan bağımsız fonksiyonlarımız varsa, multithreading kullanmalıyız. Buna örnek olarak browserdaki birden fazla tab birden fazla dosya indirirken kullanılabilir. Her bir indirme kendi thread’i ile çalışır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26e1726c806b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ASP.NET Core Asenkron Programlama(Async & Await)]]></title>
            <link>https://medium.com/@mugrcn/asp-net-core-asenkron-programlama-async-await-c660f0611172?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/c660f0611172</guid>
            <category><![CDATA[asynchronous-programming]]></category>
            <category><![CDATA[asyncawait]]></category>
            <category><![CDATA[await]]></category>
            <category><![CDATA[aspnetcore]]></category>
            <category><![CDATA[async]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Mon, 13 Oct 2025 13:38:01 GMT</pubDate>
            <atom:updated>2025-10-13T13:38:01.474Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu yazıda, ASP.NET Core projelerinde async ve await keyword’leri ile asenkron programlama hakkında konuşacağız. Bu keyword’lerin ne olduğu hakkında derinlemesine dalıp, avantajlarından bahsedip, uygulamamızı ölçeklendirmemize nasıl yardımcı olduklarını açıklamaya çalışacağız. Ayrıca, senkron bir uygulamayı async ve await keywordleri kullanarak nasıl asenkrona çevirebileceğimizi detaylarıyla anlatmaya çalışacağız. Her ne kadar biz burada ASP.NET Core Web API projesi kullanıyor olsak da buradaki bilgileri herhangi bir .NET uygulamasında kullanabilirsiniz.</p><h3>Asenkron Programlama ve Avantajları</h3><p>Asenkron programlama ile, uygulamalarımızın performans sorunlarından kurtararak cevap verme sürelerini geliştiririz. Bu teknik, uygulama akışlarının birbirini bloklamasına ve thread pool starvation sorununa çözüm getirir.</p><p>Async ve await kullanınca uygulamalarımız hızlanır gibi yanlış bir anlaşılma var ancak durum böyle değil. Örneğin, senkron çalışan uygulamamız, veritabanından bir data çektiğinde üç saniye sürüyorsa bu uygulamayı asenkron yapmak bu süreyi kısaltmaz. Ama sunucu dolaylı olarak başka isteklere de cevap verebilir hale gelir. Başka bir deyişle asenkron programlama ile uygulamamızın ölçeklenmesini artırırız.</p><p>Bu yüzden, biraz da ölçeklemenin öneminden bahsedelim.</p><p>Uygulamamızı sunucuya deploy ettiğimizde, sunucu belirli sayıda isteğe cevap verebilir. Eğer bu sayı aşılırsa sunucunun isteklere cevap verme oranı düşer. Bu durumda yeni sunucular ekleyerek bu isteklere cevap verebilir hale getiririz ve buna yatay ölçekleme denir. Diğer bir yapacağımız şey ise sunucunun memory ve CPU hızını artırarak bunu düzeltebiliriz ve buna da dikey ölçekleme denilir. Donanım ekleyerek veya upgrade etmek yerine uygulamamızı asenkron yaparsak sunucu kaynaklarını daha efektif kullanarak gerçekten ihtiyaç olduğunda bu çözümlere başvurabiliriz.</p><p>Şimdi, ASP.NET Core’da senkron ve asenkron istekler nasıl çalışıyor inceleyelim.</p><h3>ASP.NET Core’da Senkron ve Asenkron İstekler Nasıl Çalışır?</h3><p>İlk olarak senkron isteklerle başlayalım.</p><p>API’mize veritabanından şirketleri sorgulayan bir request geldiğinde, ASP.NET Core, isteği karşılaması için, thread havuzundan bir thread atar. Basit olması adına thread havuzunda 2 thread olduğunu varsayalım. Dolayısıyla bu request ile 1 thread’i kullanmış oluruz. Şimdi, ikinci bir request geldi diyelim. Bu request için de bir thread ataması yapılır. Bu durumda thread havuzunda başka thread kalmadı. Üçüncü bir request gelirse, bu request diğer iki requestin bitmesini ve thread havuzuna tekrar dönmelerini beklemek zorunda kalır. Ancak o zaman bu request için thread havuzundan yeni bir thread atanabilir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*7-hXY9CHuQqBTFVNDSxhdA.png" /></figure><p>Request’in uygun bir thread atanana kadar beklemesi sonucu client sistemin yavaşlığını tecrübe eder. Ek olarak, eğer client çok fazla beklemek zorunda kalırsa hata alır (Genelde: the service is unavailable (503)). Ama tek problem bu değil. Client veritabanından şirketlerin listesini bekliyor yani bir I/O işlemi bekliyor ve thread boştan yere 3 saniye boyunca bloklanmış oluyor. Bu yüzden de API yeni istekleri alamamış oluyor.</p><h3>Asenkron Requestler</h3><p>Asenkron isteklerde durum tamamen farklı işliyor.</p><p>API’a bir istek ulaştığında, yine thread pool’dan bir thread’e ihtiyacımız var. Ama şimdi asenkron çalıştığımız için, thread veritabanından 3 saniye boyunca sonuç bekleme noktasına geldiği anda yani bir I/O noktasına geldiği anda thread tekrardan thread pool’a döner. Bu veritabanı işlemi sonuçlandığı anda ise thread pool tekrar bir thread assign ederek bu request’in işlenmesini sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/0*PzEE004K6xomHflA.png" /></figure><p>Yani artık daha fazla request’e cevap verebilir hale geliyoruz, thread’leri bloklamıyoruz, veritabanı 3 saniye boyunca işini bitirene kadar thread’leri bekletmiyoruz. Bu sayede uygulamamızın ölçeklenmesini artırıyoruz.</p><h3>ASP.NET Core Uygulamasında Async ve Await Keyword Kullanımı</h3><p>Async ve await keywordleri asenkron programlama da kilit rol oynar. Method tanımlamalarında async keyword kullanırız ki methodun içeriğinde await keyword’ünü kullanabilelim. Yani method async tanımlanmazsa içeriğinde await kullanamayız. Aynı zamanda methodu async tanımlamak onu asenkron yapmaz tam tersine method hala senkrondur.</p><p>Await keyword’ü ise çalıştığı satırda asenkron bekleme sağlar. Bunu birkaç adımla sağlar. İlk olarak bulunduğu satır zaten tamamlanmış mı diye kontrol yapar. Eğer tamamlanmış ise method senkron olarak çalışmaya devam eder. Eğer tamamlanmamış ise await keyword’ü async methodun işleyişini duraklatıp bitmemiş bir task döner. Bir süre sonra işlem tamamlanınca async metod çalışmasına devam eder.</p><p>Basit bir örnek ile görelim:</p><pre>public async Task&lt;IEnumerable&lt;Company&gt;&gt; GetCompanies()<br>{<br>    _logger.LogInfo(&quot;Inside the GetCompanies method.&quot;);<br><br>    var companies = await _repoContext.Companies.ToListAsync();<br><br>    return companies;<br>}</pre><p>Method async olarak tanımlansa da senron olarak başlar. Log işlemi senkron olarak yapılır ve bir sonraki satır ile devam edilir. Burada veritabanından tüm şirketler çekilir. Gördüğünüz gibi burada await keyword’ünü kullanıyoruz. Burada eğer veritabanı sonucu getirmek için zamana ihtiyacı varsa await keyword’ü GetCompanies method’unun duraksatır ve tamamlanmamış bir task döner. Bu süre boyunca thread, thread pool’a tekrar döner ki başka bir request’e cevap verebilsin. Veritabanı işlemi tamamlandığında async method çalışmasını sürdürür ve şirket listesi sonucunu döner.</p><p>Örnektedn de görüldüğü üzere async metod akışı bu şekildedir. Ama soru şu; await keyword’ü işlemin tamamlanıp tamamlanmadığını nereden biliyor? İşte burada Task devreye giriyor.</p><h3>Asenkron Metodların Dönüş Tipleri</h3><p>Asenkron programlamada üç farklı dönüş tipi vardır:</p><ul><li>Task&lt;TResult&gt;, async metod için değer döner</li><li>Task, dönüş değeri olmayan methodlar için kullanılır</li><li>void, event handler için kullanılır</li></ul><p>Bunları açıklayalım.</p><p>Eğer metod Task&lt;TResult&gt; dönerse, önceki örnekte olduğu gibi, asenkron bir şekilde TResult tipinde değer döner. Yani int tipinde bir değer döneceksek dönüş değeri olarak Task&lt;int&gt; kullanmalıyız. Önceki örneğimizde IEnumerable&lt;Company&gt; tipinde bir değer dönmek istediğimiz için Task&lt;IEnumerable&lt;Company&gt;&gt; kullandık.</p><p>Eğer bir değer dönmüyorsak Task kullanırız. Yani değer dönmeden metod içerisinde await keyword’ü kullanabiliriz.</p><p>Void yalnızca asenkron event handler’lar için kullanılır. Örneğin GUI uygulamalarında buton click handler için. Bunun dışında her zaman Task kullanmlıyız. Asenkron metodlarda void kullanımı önerilmez çünkü test etmesi zordur, keza hata yakalaması da zordur. Yani özetle asenkron metodlarda söylediğimiz durumların dışında void kullanmayınız.</p><p>C# 7.0 sonrası, GetAwaiter metodu varsa başka dönüş tipleri de belirleyebiliriz.</p><p>Burada anlamamız gereken şey, Task bir sonucu değil asenkron metodun işlemesini temsil eder. Task’ın işin bitip bitmediğini gösteren property’leri bulunmaktadır (Status, IsCompleted, IsCanceled, IsFaulted). Bu property’ler ile async işlemlerin akışını takip ederiz. Buna aynı zamanda TAP (Task-based Asynchronous Pattern) denir.</p><h3>ASP.NET Core’da Async ve Await Keywordleri ile Asenkron Programlama</h3><p>Şimdi senkron projemizi asenkron olarak yeniden yazalım. <a href="https://github.com/mugrcn/async-await-aspnetcore"><strong>Github repository</strong></a> içerisinde start klasöründe başlama projemizi bulabilirsiniz. Solution içerisinde birden fazla proje görebilirsiniz ancak örneğimiz için en önemli sınıflar CompanyEmployees projesindeki CompaniesController sınıfı ve Repository projesindeki CompanyRepository sınıfıdır:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/354/0*fiSDQ5H4NoU6bv62.png" /></figure><p>Data üretmek için yalnızca appsettings.jsons dosyası içerisindeki connection string’i değiştirin ve Package Manager Console üzerinden Update-Database komutunu çalıştırın.</p><p>CompanyRepository.cs dosyasını açalım ve GetAllCompanies metodunu inceleyelim:</p><pre>public IEnumerable&lt;Company&gt; GetAllCompanies() =&gt;<br>    _repoContext.Companies<br>        .OrderBy(c =&gt; c.Name)<br>        .ToList();</pre><p>Veritabanındaki şirketleri isim sırasına göre getiren basit bir metod.</p><p>Bu metodu asenkron hale getirebilmemiz için öğrendiklerimizi uygulayalım:</p><pre>public async Task&lt;IEnumerable&lt;Company&gt;&gt; GetAllCompanies()<br>{<br>    var companies = await _repoContext.Companies<br>        .OrderBy(c =&gt; c.Name)<br>        .ToListAsync();<br><br>    return companies;<br>}</pre><p>Metod tanımına async keyword’ü ekledik ve dönüş değerini Task ile sardık. Kodda Task kullanmak içiSystem.Threading.Tasks kütüphanesini kullanmamız gerekiyor. Daha sonra metod içerisinde await keywordünü kullandık ve ToList metodunu ToListAsync şeklinde çevirdik. ToListAsync methodu Microsoft.EntityFrameworkCore namespace’inden gelmekte ve sorguları asenkron çalıştırmak amaçlı kullanılıyor. Sonuç olarak da şirketlerin listesini dönüyoruz.</p><h3>Hatalı Kullanımlar</h3><p>Asenkron işlemimizin sonucunda Result property’sinin kullanılması:</p><pre>var companies = _repoContext.Companies<br>    .OrderBy(c =&gt; c.Name)<br>    .ToListAsync()<br>    .Result;</pre><p>Görüldüğü üzereResult property’si istediğimiz sonucu dönüyor:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/0*2P9x4QtGhb1ukw5M.png" /></figure><p><strong>Bunu yapmayın.</strong></p><p><strong>Bu şekilde bir kullanım ile thread bloklanır ve uygulama potansiyel olarak deadlock’a düşer ki bu bizim async ve await keyword’leri ile kaçınmaya çalıştığımız durumdur. Aynı durum Task ile çalışabileceğimiz </strong>Wait<strong> metodu için de geçerlidir.</strong></p><p>Bunu belirttikten sonra devam ediyoruz.</p><p>CompanyRepository ICompanyRepository interface’inden türediği için burada da değişiklik yapmamız gerekiyor:</p><pre>public interface ICompanyRepository<br>{<br>    Task&lt;IEnumerable&lt;Company&gt;&gt; GetAllCompanies();<br>    Company GetCompany(Guid companyId);<br>    void CreateCompany(Company company);<br>}</pre><p>Bu kadar.</p><p>Tabiki GetAllCompanies metodu için lambda expression kullanabiliriz:</p><p>Of course, if you want, you can use a lambda expression body for our GetAllCompanies method:</p><pre>public async Task&lt;IEnumerable&lt;Company&gt;&gt; GetAllCompanies() =&gt; <br>    await _repoContext.Companies<br>        .OrderBy(c =&gt; c.Name)<br>        .ToListAsync();</pre><p>Bu size kalmış, bu şekilde kullanmak istiyorsanız kullanbilirsiniz.</p><h3>Controller Kısmının Düzenlenmesi</h3><p>Asenkron progrmalama kullanırken tüm akışı asenkron yapmamız gerekiyor. CompaniesController içerisindeki GetCompanies action’ı repository sınıfındaki async metodu çağırdığı için burayı da düzenlememiz gerekiyor:</p><pre>[HttpGet]<br>public async Task&lt;IActionResult&gt; GetCompanies()<br>{<br>    var companies = await _repository.GetAllCompanies();<br><br>    var companiesDto = _mapper.Map&lt;IEnumerable&lt;CompanyDto&gt;&gt;(companies);<br><br>    _logger.LogInfo(&quot;All companies fetched from the database&quot;);<br><br>    return Ok(companiesDto);<br>}</pre><p>Görüldüğü üzere burada üç şey değiştirdik. Metod tanımına async keyword’ü ekledik, dönüş değerini Task ile sarmaladık ve GetAllCompanies metodunu çağırırken await keyword’ünü kullandık.</p><p>Kodun geri kalanı — map kısmı, loglama kısmı ve sonucun dönülmesi — await ettiğimiz işlem tamamlandığında çalışacak. Buna <strong>continuation</strong> denilir.</p><h3>Asenkron Programlamada Continuation</h3><p>Await keyword’ü 3 şey yapar:</p><ul><li>Async işlemden sonucu almamızı sağlar</li><li>İşlemin başarılı olup olmadığını söyler</li><li>Async metod içerisindeki Continuation kısmının çalıştırılmasını sağlar</li></ul><p>Böylece GetCompanies action’ı içerisinde async işlem başarılı ise await edilen async işlemi sonrasındaki continuation kod çalıştırılır.</p><p>Continuation’dan bahsetmişken, birçok makalede SynchronizationContext hakkında yazılar görmek kafa karıştırıcı olabilir. Temel olarak, bir task await ettiğimizde metodun çalışmasını durdurmaya karar verirse request context yakalanır. Metod çalışmaya devam etmeye karar verdiği anda ise uygulama thread pool içerisinden bir thread alır ve bunu SynchonizationContext’e atar ve çalışmaya devam eder. Ama bu durum ASP.NET uygulamaları için geçerlidir.</p><p>ASP.NET Core uygulamalarında SynchronizationContext yoktur. ASP.NET Core contexti yakalayıp kuyruğa eklemekten kaçınır. Bu sayede arkaplanda daha az iş çıkar.</p><p>Bir şey daha. Tek bir continuation ile sınırlı değiliz. Metod içerisinde birden fazla await keyword’ü kullanabiliriz:</p><pre>private async Task GetCompaniesWithHttpClientFactory()<br>{<br>    var httpClient = _httpClientFactory.CreateClient();<br>    using (var response = await httpClient.GetAsync(&quot;https://localhost:5001/api/companies&quot;, HttpCompletionOption.ResponseHeadersRead))<br>    {<br>        response.EnsureSuccessStatusCode();<br>        var stream = await response.Content.ReadAsStreamAsync();<br>        var companies = await JsonSerializer.DeserializeAsync&lt;List&lt;CompanyDto&gt;&gt;(stream, _options);<br>    }<br>}</pre><p>Görüldüğü üzere action içerisinde birden fazla await kulanabiliyoruz.</p><h3>Diğer Senkron Metodları Dönüştürme</h3><p>Önceki bilgilerimize dayanarak, GetCompany metodunu ve action’ı senkrondan asenkrona çevirebilirsiniz. Her iki metod da Task&lt;T&gt; sonucu döndüğü için işlemler aynı.</p><p>Öncelikle interface’i değiştirelim:</p><pre>public interface ICompanyRepository<br>{<br>    Task&lt;IEnumerable&lt;Company&gt;&gt; GetAllCompanies();<br>    Task&lt;Company&gt; GetCompany(Guid companyId);<br>    void CreateCompany(Company company);<br>}</pre><p>Sonra metodun kendisini değiştirelim:</p><pre>public async Task&lt;Company&gt; GetCompany(Guid companyId) =&gt;<br>    await _repoContext.Companies<br>        .SingleOrDefaultAsync(c =&gt; c.Id.Equals(companyId));</pre><p>Son olarak da action’ı değiştirelim:</p><pre>[HttpGet(&quot;{id}&quot;, Name = &quot;CompanyById&quot;)]<br>public async Task&lt;IActionResult&gt; GetCompany(Guid id)<br>{<br>    var company = await _repository.GetCompany(id);<br>    if (company == null)<br>    {<br>        _logger.LogInfo($&quot;Company with id: {id} doesn&#39;t exist in the database.&quot;);<br>        return NotFound();<br>    }<br>    else<br>    {<br>        var companyDto = _mapper.Map&lt;CompanyDto&gt;(company);<br>        return Ok(companyDto);<br>    }<br>}</pre><p>Bu kadar. GetCompany veGetCompanies metodları Task&lt;T&gt; sonucu döndüğü için aynı prensipleri uygulayabiliriz.</p><p>Peki CreateCompany metodu? Şimdilik void dönüş değeri var. Daha önce de söylediğimiz gibi, eğer asenkron metodumuz bir sonuç dönmüyorsa dönüş değeri olarak yalnızca Task kullanırız.</p><p>Önce interface’i düzenleyerek başlayalım:</p><pre>public interface ICompanyRepository<br>{<br>    Task&lt;IEnumerable&lt;Company&gt;&gt; GetAllCompanies();<br>    Task&lt;Company&gt; GetCompany(Guid companyId);<br>    Task CreateCompany(Company company);<br>}</pre><p>Gördüğünüz üzere, void keyword’ü yerine yalnızca Task kullandık.</p><p>Şimdi metodun kendisini değiştirelim:</p><pre>public async Task CreateCompany(Company company)<br>{<br>    _repoContext.Add(company);<br>    await _repoContext.SaveChangesAsync();<br>}</pre><p>Şimdi de action:</p><pre>[HttpPost]<br>public async Task&lt;IActionResult&gt; CreateCompany([FromBody] CompanyForCreationDto company)<br>{<br>    if (company == null)<br>    {<br>        _logger.LogError(&quot;CompanyForCreationDto object sent from client is null.&quot;);<br>        return BadRequest(&quot;CompanyForCreationDto object is null&quot;);<br>    }<br><br>    var companyEntity = _mapper.Map&lt;Company&gt;(company);<br><br>    await _repository.CreateCompany(companyEntity);<br><br>    var companyToReturn = _mapper.Map&lt;CompanyDto&gt;(companyEntity);<br><br>    return CreatedAtRoute(&quot;CompanyById&quot;, new { id = companyToReturn.Id }, companyToReturn);<br>}</pre><p>Bu kadar.</p><p>Ama ya asenkron işlem fail olursa?</p><p>Şimdi de bunu nasıl handle edebileceğimize bakalım.</p><h3>Asenkron İşlemlerde Exception Handling</h3><p>Daha önce continuation kısmını anlatırken await keeywordünün asenkron işlemin başarılı olup olmadığını kontrol ettiğinden bahsetmiştik. Yani exception oluşma ihtimaline karşın yapmamız gereken tek şey bu kısmı try/catch bloğu içerisine almamız gerekiyor.</p><p>Yalnızca test amaçlı olarak GetAllCompanies methodunu exception fırlatacak şekilde düzenleyelim:</p><pre>public async Task&lt;IEnumerable&lt;Company&gt;&gt; GetAllCompanies()<br>{<br>    throw new Exception(&quot;Custom exception for testing purposes&quot;);<br>    return await _repoContext.Companies<br>        .OrderBy(c =&gt; c.Name)<br>        .ToListAsync();<br>}</pre><p>Şimdi GetCompanies action içerisindeki kodu try/catch bloğu içerisine alalım:</p><pre>[HttpGet]<br>public async Task&lt;IActionResult&gt; GetCompanies()<br>{<br>    try<br>    {<br>        var companies = _repository.GetAllCompanies();<br><br>        var companiesDto = _mapper.Map&lt;IEnumerable&lt;CompanyDto&gt;&gt;(companies);<br><br>        _logger.LogInfo(&quot;All companies fetched from the database&quot;);<br><br>        return Ok(companiesDto);<br>    }<br>    catch (Exception ex)<br>    {<br>        _logger.LogError($&quot;Exception occurred with a message: {ex.Message}&quot;);<br>        return StatusCode(500, ex.Message);<br>    }<br>}</pre><p>Dikkat ederseniz async işlemlerin await keyword’ü olmadan nasıl davrandığını göstermek için sildik.</p><p>Action içerisine breakpoint koyup Postman ile istek gönderirsek, async işlem bize faulted task döncektir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/950/0*iloWEjng9NH7BLP7.png" /></figure><p>Bu task tek bir exception’a sahip ve Status property’si Faulted olarak setlenmiş. Ancak gördüğünüz üzere kodumuz catch bloğuna girmeden çalışmaya devam etti. Bunun sebebi, await keyword’ü olmadan task exception’ı yutar. Aslında hata durumunda devam etmemesini istememize rağmen kod çalışmaya devam eder ve mapping exception’ı alır.</p><p>Await keyword’ünü olması gereken yere tekrar koyalım:</p><pre>var companies = await _repository.GetAllCompanies();</pre><p>Kodu şimdi çalıştırdığımızda await keyword’ü işlemi validate eder ve taskın faulted state’de olduğunu görür görmez catch bloğunu çalıtırmaya geçer. Bu sayede Postman’de ve loglarda hata mesajını görebiliriz:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/0*dFolssoQwd9THDrW.png" /></figure><p>İşte bu kadar.</p><p>Tabiki kodunuzun her yerine eklemek istemeyebilirsiniz, bunun için bu yazının konusu olmayan Global Exception Handling tekniklerine göz atabilirsiniz.</p><p>Async await konusu ile anlatacaklarımız bu kadar. Başka bir yazıda görüşmek üzere.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c660f0611172" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bir Metodun Farklı .NET Versiyonlarındaki Benchmarkları Nasıl Yapılır]]></title>
            <link>https://medium.com/@mugrcn/bir-metodun-farkl%C4%B1-net-versiyonlar%C4%B1ndaki-benchmarklar%C4%B1-nas%C4%B1l-yap%C4%B1l%C4%B1r-cc1f5aa368e3?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc1f5aa368e3</guid>
            <category><![CDATA[net-core]]></category>
            <category><![CDATA[benchmarking]]></category>
            <category><![CDATA[benchmark]]></category>
            <category><![CDATA[csharp]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Wed, 27 Mar 2024 12:49:28 GMT</pubDate>
            <atom:updated>2024-03-27T12:49:28.581Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bir Metodun Farklı .NET Versiyonlarındaki Benchmarkları Nasıl Yapılır</h3><p>.NET geliştiricileri olarak, genelde yazdığımız bir metodun performans ölçümlerini yaparken tek bir .NET versiyonu üzerinden kontrol ederiz. Aslında bu ölçümleri farklı .NET versiyonları için de kontrol edebiliriz. Bu benchmarklar, kodu yeni versiyona taşırken çok faydalı olabilir. Bu gibi senaryolarda, potansiyel hızlanmayı ve yavaşlamayı çok rahat görebiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*5IlujKLTGZCklQ8Pg73gPA.png" /><figcaption>Benchmark dotnet applications</figcaption></figure><p>Bu yazıda, BenchmarkDotNet kütüphanesini kullanarak farklı .NET versiyonları üzerinde benchmark değerlerini nasıl görebiliriz onu göreceğiz.</p><h4>Benchmark Ortamını Hazırlama</h4><p>Benchmark yapmak istediğimiz metodu tanımlamadan önce komut satırından projemizi oluşturalım:</p><pre>dotnet new console -o BenchmarkAcrossDifferentDotNETVersions</pre><p>Şimdi de oluşturduğumuz projeye BenchmarkDotNet<strong> paketini </strong>ekleyelim:</p><pre>dotnet add package BenchmarkDotNet</pre><p>Son olarak, benchmark yapacağımız farklı <strong>.NET SDKlarını </strong><a href="https://dotnet.microsoft.com/en-us/download/dotnet"><strong>.NET download sayfası</strong></a><strong> üzerinden indirelim</strong>. Biz burada .NET 6.0, .NET 7.0, and .NET 8.0 SDK’larını kullanacağız.</p><p>SDK’ları indirip yükledikten sonra, bunlarla çalışacak projemizi düzenleyelim. Bunun için .csproj dosyasını aşağıdaki gibi düzenleyelim:</p><pre>&lt;Project Sdk=&quot;Microsoft.NET.Sdk&quot;&gt;<br><br>    &lt;PropertyGroup&gt;<br>        &lt;OutputType&gt;Exe&lt;/OutputType&gt;<br>        &lt;TargetFrameworks&gt;net6.0;net7.0;net8.0&lt;/TargetFrameworks&gt;<br>        &lt;ImplicitUsings&gt;enable&lt;/ImplicitUsings&gt;<br>        &lt;Nullable&gt;enable&lt;/Nullable&gt;<br>    &lt;/PropertyGroup&gt;<br><br>    &lt;ItemGroup&gt;<br>        &lt;PackageReference Include=&quot;BenchmarkDotNet&quot; Version=&quot;0.13.12&quot; /&gt;<br>    &lt;/ItemGroup&gt;<br><br>&lt;/Project&gt;</pre><p>Aslında burada sadece .csproj dosyası içerisindeki &lt;TargetFramework&gt;netx.0&lt;/TargetFramework&gt;<strong> satırını </strong>&lt;TargetFrameworks&gt;net6.0;net7.0;net8.0&lt;/TargetFrameworks&gt; ile değiştirdik.</p><p>Şimdi benchmark yapmak istediğimiz metodu tanımlayalım:</p><pre>public record Book(string Title, string Author, string Publisher);<br><br>public class BookService<br>{<br>    public static List&lt;Book&gt; GetBooks()<br>        =&gt; new()<br>        {<br>            new(&quot;Measuring Time&quot;, &quot;Helon Habila&quot;, &quot;W. W. Norton &amp; Company&quot;),<br>            new(&quot;Americanah&quot;, &quot;Chimamanda Adichie&quot;, &quot;Alfred Knopf&quot;),<br>            new(&quot;Things Fall Apart&quot;, &quot;Chinua Achebe&quot;, &quot;William Heinemann Ltd.&quot;)<br>        };<br>}</pre><p>Burada üç property’li Book <a href="https://code-maze.com/csharp-records/">record</a> oluşturduk. Daha sonra BookService class’ını oluşturduk ve içerisinde tüm kitapları list şeklinde dönen bir metod ekledik.</p><p><strong>Unutmayın burada kullandığımız C# versiyonu test etmek istediğimiz tüm .NET versiyonları ile birlikte çalışabilmelidir</strong>. Örneğin bu method içerisinde <a href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/collection-expressions"><strong>collection expressions</strong></a> kullanamayız, çünkü bu özellik .NET 8 SDK içerisinde C# 12 ile birlikte geldi. Bu özellik .NET 6 ve .NET 7 SDKları içerisinde C# 10 ve C# 11 içerisinde kullanılamıyor.</p><p>Bu işlemleri tamamladıktan sonra benchmark sınıfımızı oluşturup çalıştıralım.</p><h4>Farklı .NET versiyonları için benchmark oluşturup çalıştıralım</h4><p>GetBooksBenchmark sınıfımızı oluşturalım:</p><pre>[SimpleJob(RuntimeMoniker.Net60, baseline: true)]<br>[SimpleJob(RuntimeMoniker.Net70)]<br>[SimpleJob(RuntimeMoniker.Net80)]<br>[Config(typeof(StyleConfig))]<br>public class GetBooksBenchmark<br>{<br>    private class StyleConfig : ManualConfig<br>    {<br>        public StyleConfig()<br>            =&gt; SummaryStyle = SummaryStyle.Default.WithRatioStyle(RatioStyle.Trend);<br>    }<br><br>    [Benchmark]<br>    public List&lt;Book&gt; GetBooks() =&gt; BookService.GetBooks();<br>}</pre><p>Burada <strong>benchmark’ımızın .NET 6.0, .NET 7.0, ve .NET 8.0 arasında yapılacağını belirtmek için </strong>[SimpleJob(RuntimeMoniker.Netxx)]<strong> attribute’ü kullandık</strong>. Ayrıca benchmark’ın baseline’ı olarak .NET 6.0 runtime seçildi. Bu, BenchmarkDotnet diğer runtime’lardan elde ettiği verileri .NET 6.0. dan elde ettiği verilerle karşılaştıracak demektir.</p><p>Daha bilgilendirici benchmark sonuçları elde etmek için buraya [Config(typeof(StyleConfig))] attribute’ü ekledik.</p><p>StyleConfig class’ı içerisinde, SummaryStyle property’sini SummaryStyle.Default.WithRatioStyle(RatioStyle.Trend) olarak set eden StyleConfig() metodu tanımladık. Aslında yapmaya çalıştığımız şey varsayılan sonuç özet stilini kullanmak ancak ratio sütunu olarak .NET 6.0 ile diğer runtime’lardan elde edilen sonuçların oransal karşılaştırmasını gözlemlemek. Not olarak; StyleConfig sınıfı private olarak tanımlandı çünkü başka bir sınıf bu sınıfa erişmeye çalışmıyor.</p><p>Son olarak da, benchmark yapmak istediğimiz method GetBooks() metodu olduğu için buraya Benchmark attribute ekliyoruz.</p><p>Program.cs class’ı içerisinde benchmark’ı çalıştıracak kodu ekliyoruz:</p><pre>BenchmarkRunner.Run&lt;GetBooksBenchmark&gt;();</pre><p>Şimdi uygulamayı çalıştıralım ve sonuçları inceleyelim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*8dGtvYLS512uBGJKgN58Hw.png" /></figure><p>Buradaki benchmark sonuçlarından GetBooks() metodunun .NET 6.0, .NET 7.0, and .NET 8.0 versiyonlarındaki değerlerini gözlemleyebiliyoruz. Ratio hangi versiyonun baseline versiyonuna göre ne kadar hızlı veya yavaş çalıştığını görebiliyoruz.</p><p>Böylece metodumuzun farklı .NET versiyonlarında çalışma hızlarını karşılaştırmış olduk.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc1f5aa368e3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOLID Prensipleri — C#]]></title>
            <link>https://medium.com/@mugrcn/solid-prensipleri-c-d6c8980a0a93?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d6c8980a0a93</guid>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[solid-principles]]></category>
            <category><![CDATA[principles]]></category>
            <category><![CDATA[programming-tips]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Mon, 12 Feb 2024 07:28:38 GMT</pubDate>
            <atom:updated>2024-02-12T07:28:38.299Z</atom:updated>
            <content:encoded><![CDATA[<h3>SOLID Prensipleri — C#</h3><p>SOLID prensipleri, uygulanması durumunda kod kalitesini ciddi anlamda artıran prensiplerdir. Tüm yazılımcılar bu prensipleri mutlaka duymuştur. Kod yazarken uygulamasa da iş mülakatı öncesi bu prensiplerin üzerinden bir kere geçmiştir. :) Bu yazıda örnekler üzerinden giderek, konunun daha kolay anlaşılmasını sağlamaya çalışacağım.</p><p>Diğer prensiplerde olduğu gibi SOLID prensiplerinde de yanlış ya da aşırı kullanım sonucunda istediğimizin tam tersi sonuçlarla karşılaşmamız mümkün. Sonuç olarak elimize, anlaşılabilir, sürdürülebilir ve esnek bir kod yerine tam tersi kötü bir kod geçebilir.</p><p>Bu yüzden, SOLID prensiplerini uygularken çok dikkatli kullanmalıyız.</p><p>SOLID kelimesi aşağıdaki prensiplerin baş harflerinden oluşmaktadır:</p><ul><li>S — Single Responsibility</li><li>O — Open/Closed</li><li>L — Liskov Substitution</li><li>I — Interface Segregation</li><li>D — Dependency Inversion</li></ul><h4>Single Responsibility Prensibi</h4><p>Bir proje geliştirirken, sürdürülebilir ve okunabilir kod yazmakta zorlanırız. Bunu başarmak için her bir sınıf yalnızca ve sadece kendi işini yapmalıdır. Evet, bir sınıfın birden fazla iş yapmaması çok önemlidir. Eğer yaparsa, birden fazla iş yapmasından dolayı, ileride istenilen değişikliklerde, kodda değişiklik olma ihtimali artar ve sürdürülebilirliği azalır.</p><p>Single Responsibility Prensibi der ki; Bir sınıf yalnızca tek bir sebep ile değişikliğe uğramalıdır. Diğer bir deyişle; sınıfların sorumlu olduğu tek bir konu olmalıdır. Bu kadar basit.</p><p>Örnekler üzerinden giderek, konuyu daha iyi anlatmaya çalışacağım. Aşağıdaki örnekte SRP’ye uymayan bir kod ile başlayıp bunu değiştirerek SRP’ye uygun hale getirmeye çalışacağız.</p><p><strong>Projeyi Oluşturalım</strong></p><p>Basit bir console uygulaması oluşturalım.</p><p>Düşünün ki, <em>uygulamamıza çalışma kaydı raporlama özelliği ekleyeceğiz ve bu rapor oluşturulduktan sonra; dosya olarak kaydedilebilir, buluta upload edilebilir veya başka amaçla kullanılabilir olsun.</em></p><p>Bunun için basit bir model sınıfı üreterek başlayalım:</p><pre>public class WorkReportEntry<br>{<br>    public string ProjectCode { get; set; }<br>    public string ProjectName { get; set; }<br>    public int SpentHours { get; set; }<br>}</pre><p>Bir sonraki adımda projemizin ihtiyacı olan özellikleri barındıran WorkReport sınıfını oluşturalım:</p><pre>public class WorkReport<br>{<br>    private readonly List&lt;WorkReportEntry&gt; _entries;<br><br>    public WorkReport()<br>    {<br>        _entries = new List&lt;WorkReportEntry&gt;();<br>    }<br><br>    public void AddEntry(WorkReportEntry entry) =&gt; _entries.Add(entry);<br><br>    public void RemoveEntryAt(int index) =&gt; _entries.RemoveAt(index);<br><br>    public override string ToString() =&gt;<br>        string.Join(Environment.NewLine, _entries.Select(x =&gt; $&quot;Code: {x.ProjectCode}, Name: {x.ProjectName}, Hours: {x.SpentHours}&quot;));<br>}</pre><p>Bu sınıfta, çalışma kayıtlarını bir listede tutarak ekleme/silme işlemleri yapıyoruz. Ek olarak, ToString() methodunu ihtiyacımız doğrultusunda override ediyoruz.</p><p>Artık WorkReport sınıfımıza istediğimiz özellikleri ekleyebiliriz. Örneğin dosyaya kaydetme işlemi (SaveToFile methodu):</p><pre>public class WorkReport<br>{<br>    private readonly List&lt;WorkReportEntry&gt; _entries;<br><br>    public WorkReport()<br>    {<br>        _entries = new List&lt;WorkReportEntry&gt;();<br>    }<br><br>    public void AddEntry(WorkReportEntry entry) =&gt; _entries.Add(entry);<br><br>    public void RemoveEntryAt(int index) =&gt; _entries.RemoveAt(index);<br><br>    public void SaveToFile(string directoryPath, string fileName)<br>    {<br>        if(!Directory.Exists(directoryPath))<br>        {<br>            Directory.CreateDirectory(directoryPath);<br>        }<br>        <br>        File.WriteAllText(Path.Combine(directoryPath, fileName), ToString());<br>    }<br><br>    public override string ToString() =&gt;<br>        string.Join(Environment.NewLine, _entries.Select(x =&gt; $&quot;Code: {x.ProjectCode}, Name: {x.ProjectName}, Hours: {x.SpentHours}&quot;));<br>}</pre><p><strong>Bu Koddaki Problemler</strong></p><p>Bu sınıfa Load veya UploadToCloud methodları gibi yeni özellikler ekleyebiliriz çünkü hepsi WorkReport ile alakalı işler ama sırf alakalı diye buraya ekleyebiliriz anlamına gelmiyor.</p><p>Şu anda, WorkReport sınıfı ile ilgili tek bir mesele var.</p><p><strong>Birden fazla sorumluluğu var.</strong></p><p>Artık sadece iş raporlarının kaydını tutmuyor aynı zamanda bu iş raporlarını dosyaya da kaydetmekten sorumlu. Bu SRP’yi ihlal ettiğimiz anlamına geliyor ve gelecekte değişikliğe uğraması için birden fazla nedeni var.</p><p>Bu sınıfta ileride yapılması muhtemel değişikliğin ilk sebebi; iş raporu kayıtlarını saklama yöntemimizde değişikliğe gitmek. Ancak dosyayı farklı şekilde kaydetmek istersek tamamen yeni bir sebebimiz olmuş oluyor. Ve bu sınıfa daha fazla sorumluluk eklediğimizi düşünün. Bir sınıfta birbiriyle ilgisi olmayan bir sürü kod parçası olurdu.</p><p>Bundan kaçınmak için, kodu refactor edelim.</p><p><strong>SRP için Refactor</strong></p><p>Yapacağımız ilk şey birbiriyle ilgisi olmayan kod parçalarını ayırmak olacaktır. Bizim senaryomuzda bu açıkça görüldüğü üzere SaveToFile methodu olacak, dolayısıyla bu methodu başka bir sınıfa aktaracağız:</p><pre>public class FileSaver<br>{<br>    public void SaveToFile(string directoryPath, string fileName, WorkReport report)<br>    {<br>        if (!Directory.Exists(directoryPath))<br>        {<br>            Directory.CreateDirectory(directoryPath);<br>        }<br><br>            File.WriteAllText(Path.Combine(directoryPath, fileName), report.ToString());<br>        }<br>    }<br>}</pre><pre>public class WorkReport<br>{<br>    private readonly List&lt;WorkReportEntry&gt; _entries;<br><br>    public WorkReport()<br>    {<br>        _entries = new List&lt;WorkReportEntry&gt;();<br>    }<br><br>    public void AddEntry(WorkReportEntry entry) =&gt; _entries.Add(entry);<br><br>    public void RemoveEntryAt(int index) =&gt; _entries.RemoveAt(index);<br><br>    public override string ToString() =&gt;<br>        string.Join(Environment.NewLine, _entries.Select(x =&gt; $&quot;Code: {x.ProjectCode}, Name: {x.ProjectName}, Hours: {x.SpentHours}&quot;));<br>}</pre><p>Bu durumda, sorumluluğu iki sınıfa bölmüş olduk. Artık WorkReport sınıfı çalışma raporlarının kayıtlarının takibinden sorumlu FileSaver sınıfı ise dosya kaydından sorumlu.</p><p>Bunu yaparak her bir sınıfın sorumluluğunu ayırmış olduk böylece kod hem sürdürülebilir hem de daha okunaklı hale geldi. Sonuç olarak dosya kaydı biçiminde bir değişikliğe gideceksek yalnızca FileSaver sınıfında değişiklik yapmamız yeterli olacaktır.</p><p>Her şeyin istediğimiz gibi çalışıp çalışmadığını kontrol edebiliriz:</p><pre>class Program<br>{<br>    static void Main(string[] args)<br>    {<br>        var report = new WorkReport();<br>        report.AddEntry(new WorkReportEntry { ProjectCode = &quot;123Ds&quot;, ProjectName = &quot;Project1&quot;, SpentHours = 5 });<br>        report.AddEntry(new WorkReportEntry { ProjectCode = &quot;987Fc&quot;, ProjectName = &quot;Project2&quot;, SpentHours = 3 });<br><br>        Console.WriteLine(report.ToString());<br><br>        var saver = new FileSaver();<br>        saver.SaveToFile(@&quot;Reports&quot;, &quot;WorkReport.txt&quot;, report);<br>    }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/381/0*73jybg51EFBBZfum.png" /></figure><p><strong>Kodu Daha da İyileştirelim</strong></p><p>SaveToFile methodumuza bakarsak dosya kaydetme işini yaptığını görebiliriz ancak daha iyisini de yapabilir mi? Bu method WorkReport sınıfı ile sıkı sıkıya bağlı. Ya zamanlanmış görevleri takip eden yeni bir Scheduler sınıfı oluşturmak istersek ne olur? Yine de bunu bir dosyaya kaydedeceğiz. Bu durumda kodda değişiklik yapmamız gerekecek:</p><pre>public interface IEntryManager&lt;T&gt;<br>{<br>    void AddEntry(T entry);<br>    void RemoveEntryAt(int index);<br>}</pre><p>WorkReport sınıfında yapacağımız tek değişiklik şu interface’i implement etmek olacaktır:</p><pre>public class WorkReport: IEntryManager&lt;WorkReportEntry&gt;</pre><p>Son olarak SaveToFile methodunu değiştirmemiz gerekiyor:</p><pre>public void SaveToFile&lt;T&gt;(string directoryPath, string fileName, IEntryManager&lt;T&gt; workReport)</pre><p>Bu düzenlemelerden sonra uygulamamızın çalışmasından bir değişiklik olmayacak ancak şimdi Scheduler sınıfını implement etmek çok basit olacak:</p><pre>public class ScheduleTask<br>{<br>    public int TaskId { get; set; }<br>    public string Content { get; set; }<br>    public DateTime ExecuteOn { get; set; }<br>}</pre><pre>public class Scheduler : IEntryManager&lt;ScheduleTask&gt;<br>{<br>    private readonly List&lt;ScheduleTask&gt; _scheduleTasks;<br><br>    public Scheduler()<br>    {<br>        _scheduleTasks = new List&lt;ScheduleTask&gt;();<br>    }<br><br>    public void AddEntry(ScheduleTask entry) =&gt; _scheduleTasks.Add(entry);<br><br>    public void RemoveEntryAt(int index) =&gt; _scheduleTasks.RemoveAt(index);<br><br>    public override string ToString() =&gt; <br>        string.Join(Environment.NewLine, _scheduleTasks.Select(x =&gt; $&quot;Task with id: {x.TaskId} with content: {x.Content} is going to be executed on: {x.ExecuteOn}&quot;));<br>}</pre><pre>class Program<br>{<br>    static void Main(string[] args)<br>    {<br>        var report = new WorkReport();<br>        report.AddEntry(new WorkReportEntry { ProjectCode = &quot;123Ds&quot;, ProjectName = &quot;Project1&quot;, SpentHours = 5 });<br>        report.AddEntry(new WorkReportEntry { ProjectCode = &quot;987Fc&quot;, ProjectName = &quot;Project2&quot;, SpentHours = 3 });<br><br>        var scheduler = new Scheduler();<br>        scheduler.AddEntry(new ScheduleTask { TaskId = 1, Content = &quot;Do something now.&quot;, ExecuteOn = DateTime.Now.AddDays(5) });<br>        scheduler.AddEntry(new ScheduleTask { TaskId = 2, Content = &quot;Don&#39;t forget to...&quot;, ExecuteOn = DateTime.Now.AddDays(2) });<br><br>        Console.WriteLine(report.ToString());<br>        Console.WriteLine(scheduler.ToString());<br><br>        var saver = new FileSaver();<br>        saver.SaveToFile(@&quot;Reports&quot;, &quot;WorkReport.txt&quot;, report);<br>        saver.SaveToFile(@&quot;Schedulers&quot;, &quot;Schedule.txt&quot;, scheduler);<br>    }<br>}</pre><p>Kodu çalıştırdığımızda dosyamız olması gerektiği yer ve zamanda kaydedilecek.</p><p>Şimdi artık elimizdeki her sınıf yalnızca ve yalnızca tek bir işten sorumlu.</p><p><strong>Single Responsibility Prensibinin Faydaları</strong></p><p>Kodumu SRP ile birlikte birçok yönden gelişti. İlk olarak karmaşıklığı azaldı. Her sınıfın tek bir görevi olduğu için okuması basitleşti. Karmaşıklığın azalmasıyla birlikte sürdürülebilirliği arttı.</p><p>Örnekten de görüldüğü üzere, yazdığımız sınıf işini iyi yaptığı sürece başka projelerde de kullanılabilir hale geldi. Dahası kodu test etmesi daha da basitleşti.</p><p>Kodumuzda SRP’yi uyguladığımızda, methodlarımız <em>coherent </em>hale geldi. Bunun anlamı farklı methodların tek bir işi, birlikte uyumlu bir şekilde çalışarak yapması demektir.</p><p>Son olarak sınıflarımız birbirlerine daha az bağımlı (decoupled) hale geldi ki bu bir projede çalışırken en önemli şeylerden biridir.</p><p><strong>SRP’nin Potansiyel Eksileri</strong></p><p>Oluşturduğumuz sınıflarda “değişim tek bir sebebe bağlı olmalıdır” kuralını kesin çizgilerle gösteren bir işaret yoktur. Kuralın uygulanışını herkes kendine göre ya da nasıl hissediyorsa öyle yorumlar. Kuralların kesin çizgilerle çizilmemesinden dolayı herkes “kendi doğrusu”na göre hareket ederek uygular.</p><p>Ama yine de, bu kuralı kim nasıl yorumlarsa yorumlasın, kodumuzun okunabilir ve sürdürülebilir olması için kendimizce doğru yol ne ise SRP kuralını uygulamalıyız.</p><p>SRP prensibinin eksi yönlerinden biri de, halihazırda yazılım projelerde bu prensibi uygulamanın zor olmasıdır. Tamamen uygulanamaz değildir ancak daha fazla zaman ve kaynak gerektirir.</p><p>SRP uygulamak aynı zamanda küçük ve bütünleşik methodlar yazmamızı da sağlar. İlk bakışta bu iyi gibi görünebilir ancak büyük sınıfları küçük parçalara bölmek risk oluşturur. Eğer bu tarz sınıflar iyi organize edilmemiş ise, daha sonradan sistemde değişiklik yapmak ve kodu anlamak zorlaşır ki bu istemediğimiz bir durumdur.</p><h4>Open/Closed Prensibi</h4><p>Open/Closed prensibi, yazılım birimlerinin (sınıflar ve methodlar) değişime kapalı yeni özelliklere açık olması gerektiğini belirtir.</p><p>Peki bunun anlamı nedir?</p><p>Bunun anlamı basitçe; öyle bir kod yazmalıyız ki müşteri her değişiklik istediğinde kodu değiştirme ihtiyacı duymamalıyız. Yani amacımız; sınıfın davranışını genişletmeli ancak sınıfa dokunmamalıyız.</p><p>Bu prensibi örnekle açıklamaya çalışalım. Başta hiçbiri OCP kurallarına uymayacak ancak refactor yaparak OCP kurallarına uymasını sağlayacağız. İlk örneğimizle başlayalım.</p><p><strong>Maaş Hesaplayıcı Örneği</strong></p><p>Diyelim ki; bir şirkette çalışan tüm yazılımcıların toplam maaşını hesaplaması gereken bir işimiz var. Her zaman olduğu gibi örneği anlayabilme açısından işi basit tutacağız.</p><p>İlk olarak model sınıfımızı oluşturalım:</p><pre>public class DeveloperReport<br>{<br>    public int Id { get; set; }<br>    public string Name { get; set; }<br>    public string Level { get; set; }<br>    public int WorkingHours { get; set; }<br>    public double HourlyRate { get; set; }<br>}</pre><p>Modelimizi oluşturduktan sonra maaş hesaplama özelliğimizi oluşturmaya geçebiliriz:</p><pre>public class SalaryCalculator<br>{<br>    private readonly IEnumerable&lt;DeveloperReport&gt; _developerReports;<br><br>    public SalaryCalculator(List &lt;DeveloperReport&gt; developerReports)<br>    {<br>        _developerReports = developerReports;<br>    }<br><br>    public double CalculateTotalSalaries()<br>    {<br>        double totalSalaries = 0D ;<br><br>        foreach (var devReport in _developerReports)<br>        {<br>            totalSalaries += devReport.HourlyRate * devReport.WorkingHours;<br>        }<br><br>        return totalSalaries;<br>    }<br>}</pre><p>Şimdi, hesaplama yapabilmemiz için tek yapmamız gereken bu sınıfa veri sağlamak:</p><pre>static void Main(string[] args)<br>{<br>    var devReports = new List&lt;DeveloperReport&gt;<br>    {<br>        new DeveloperReport {Id = 1, Name = &quot;Dev1&quot;, Level = &quot;Senior developer&quot;, HourlyRate  = 30.5, WorkingHours = 160 },<br>        new DeveloperReport {Id = 2, Name = &quot;Dev2&quot;, Level = &quot;Junior developer&quot;, HourlyRate  = 20, WorkingHours = 150 },<br>        new DeveloperReport {Id = 3, Name = &quot;Dev3&quot;, Level = &quot;Senior developer&quot;, HourlyRate  = 30.5, WorkingHours = 180 }<br>    };<br><br>    var calculator = new SalaryCalculator(devReports);<br>    Console.WriteLine($&quot;Sum of all the developer salaries is {calculator.CalculateTotalSalaries()} dollars&quot;);<br>}</pre><p>Uygulamamızın çıktısı şu şekilde:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/477/0*2H43juq9lRUQIJYF.png" /></figure><p>Her şey çok iyi çalışıyor, ancak patron ofise geldi ve dedi ki senior ve junior developer maaşları farklı şekilde hesaplansın ve senior developer’ların maaşlarına %20 prim eklensin.</p><p>Tabi ki bu ihtiyacı karşılamak için CalculateTotalSalaries methodunda düzenleme yapmalıyız:</p><pre>public double CalculateTotalSalaries()<br>{<br>    double totalSalaries = 0D;<br><br>    foreach (var devReport in _developerReports)<br>    {<br>        if(devReport.Level == &quot;Senior developer&quot;)<br>        {<br>            totalSalaries += devReport.HourRate * devReport.WorkingHours * 1.2;<br>        }<br>        else<br>        {<br>            totalSalaries += devReport.HourRate * devReport.WorkingHours;<br>        }<br>    }<br><br>    return totalSalaries;<br>}</pre><p>İstediğimiz sonucu verse de bu doğru bir çözüm değil. Çünkü çok iyi çalışan bir sınıfın davranışında değişiklik yapmak için düzenleme yaptık. Patron tekrar gelip başka bir değişiklik isterse burada bir düzenleme daha yapmamız gerekecek. İşte OCP bu durumun tam tersini savunur.</p><p>Şimdi de olması gereken çözümü üretelim.</p><p><strong>Daha İyi Maaş Hesaplayıcı Örneği — OCP Uygulanmış</strong></p><p>Bunun için öncelikle abstract bir sınıf oluşturalım:</p><pre>public abstract class BaseSalaryCalculator<br>{<br>    protected DeveloperReport DeveloperReport { get; private set; }<br><br>    public BaseSalaryCalculator(DeveloperReport developerReport)<br>    {<br>        DeveloperReport = developerReport;<br>    }<br><br>    public abstract double CalculateSalary();<br>}</pre><p>Bunun devamında BaseSalaryCalculator sınıfından türeyen iki sınıf daha oluşturalım:</p><pre>public class SeniorDevSalaryCalculator : BaseSalaryCalculator<br>{<br>    public SeniorDevSalaryCalculator(DeveloperReport report)<br>        :base(report)<br>    {<br>    }<br><br>    public override double CalculateSalary() =&gt; DeveloperReport.HourlyRate * DeveloperReport.WorkingHours * 1.2;<br>}</pre><pre>public class JuniorDevSalaryCalculator : BaseSalaryCalculator<br>{<br>    public JuniorDevSalaryCalculator(DeveloperReport developerReport)<br>        :base(developerReport)<br>    {<br>    }<br><br>    public override double CalculateSalary() =&gt; DeveloperReport.HourlyRate * DeveloperReport.WorkingHours;<br>} </pre><p>Şimdi deSalaryCalculator sınıfımızı düzenleyelim:</p><pre>public class SalaryCalculator<br>{<br>    private readonly IEnumerable&lt;BaseSalaryCalculator&gt; _developerCalculation;<br><br>    public SalaryCalculator(IEnumerable&lt;BaseSalaryCalculator&gt; developerCalculation)<br>    {<br>        _developerCalculation = developerCalculation;<br>    }<br><br>    public double CalculateTotalSalaries()<br>    {<br>        double totalSalaries = 0;<br><br>        foreach (var devCalc in _developerCalculation)<br>        {<br>            totalSalaries += devCalc.CalculateSalary();<br>        }<br><br>        return totalSalaries;<br>    }<br>}</pre><p>Bu düzenleme ile birlikte OCP uygulamış olduk. Patron başka bir değişiklik istediğinde buranın kodunda herhangi bir düzenleme yapmamıza gerek kalmadı. Yalnızca kendi hesaplama mantığına sahip başka bir sınıf eklememiz yeterli olacaktır.</p><p>Yani artıkSalaryCalculator sınıfı yeniliğe açık değişime kapalı hale gelmiş oldu.</p><p>Örneği tamamlamak için son olarak Program.cs sınıfını aşağıdaki şekilde düzenleyelim.</p><pre>class Program<br>{<br>    static void Main(string[] args)<br>    {<br>        var devCalculations = new List&lt;BaseSalaryCalculator&gt;<br>        {<br>            new SeniorDevSalaryCalculator(new DeveloperReport {Id = 1, Name = &quot;Dev1&quot;, Level = &quot;Senior developer&quot;, HourlyRate = 30.5, WorkingHours = 160 }),<br>            new JuniorDevSalaryCalculator(new DeveloperReport {Id = 2, Name = &quot;Dev2&quot;, Level = &quot;Junior developer&quot;, HourlyRate = 20, WorkingHours = 150 }),<br>            new SeniorDevSalaryCalculator(new DeveloperReport {Id = 3, Name = &quot;Dev3&quot;, Level = &quot;Senior developer&quot;, HourlyRate = 30.5, WorkingHours = 180 })<br>        };<br><br>        var calculator = new SalaryCalculator(devCalculations);<br>        Console.WriteLine($&quot;Sum of all the developer salaries is {calculator.CalculateTotalSalaries()} dollars&quot;);<br>    }<br>} </pre><h4>Liskov Substitution Prensibi</h4><p>LSP der ki; Alt sınıf nesneleri, uygulama bütünlüğünden ödün vermeden üst sınıf nesnelerinin yerini alabilmelidir. Bunun temel anlamı; öyle alt sınıf nesneleri oluşturmalıyız ki yeri geldiğinde kodu değiştirmeden üst sınıf nesneler yerine kullanılabilmelidir.</p><p>Bunu daha iyi anlayabilmek için “Sum Caclulator” isimli bir örnek oluşturacağız.</p><p><strong>Sum Calculator Örneği</strong></p><p>Bu örnekte, elimizde sayılardan oluşan bir array ve bu arraydeki sayıların toplamını hesaplayan bir methodumuz bulunmakta.</p><pre>public class SumCalculator<br>{<br>    protected readonly int[] _numbers;<br><br>    public SumCalculator(int[] numbers)<br>    {<br>        _numbers = numbers;<br>    }<br><br>    public int Calculate() =&gt; _numbers.Sum();<br>}</pre><pre>public class EvenNumbersSumCalculator: SumCalculator<br>{<br>    public EvenNumbersSumCalculator(int[] numbers)<br>        :base(numbers)<br>    {<br>    }<br><br>    public new int Calculate() =&gt; _numbers.Where(x =&gt; x % 2 == 0).Sum();<br>}</pre><p>Bunu test etmek için aşağıdaki düzenlemeyi yapalım:</p><pre>class Program<br>{<br>    static void Main(string[] args)<br>    {<br>        var numbers = new int[] { 5, 7, 9, 8, 1, 6, 4 };<br><br>        SumCalculator sum = new SumCalculator(numbers);<br>        Console.WriteLine($&quot;The sum of all the numbers: {sum.Calculate()}&quot;);<br><br>        Console.WriteLine();<br><br>        EvenNumbersSumCalculator evenSum = new EvenNumbersSumCalculator(numbers);<br>        Console.WriteLine($&quot;The sum of all the even numbers: {evenSum.Calculate()}&quot;);<br>    }<br>}</pre><p>Sonuç:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/332/0*uCYx0nYLtKhGh6FL.png" /></figure><p>Uygulamamız beklendiği şekilde çalıştı. Ancak bu çözümdeki sorun ne o zaman? Neyi düzeltmeye çalışacağız?</p><p>Bildiğimiz üzere alt sınıf üst sınıftan türerse alt sınıf üst sınıfa dönüşmüş oluyor. Dolayısıyla, SumCalculator referansıyla EvenNumbersSumCalculator oluşturabiliriz ve hiçbirşey değiştirmemize gerek kalmaz. Şimdi bunu uygulayalım:</p><pre>SumCalculator evenSum = new EvenNumbersSumCalculator(numbers);<br>Console.WriteLine($&quot;The sum of all the even numbers: {evenSum.Calculate()}&quot;);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/337/0*tDlOeWclGttEGhwa.png" /></figure><p>Gördüğünüz üzere sonuç beklediğimiz gibi değil çünkü evenSum SumCalculator tipinde yani üst sınıfa ait (base class) bir değişken. Bu da demek oluyor ki SumCalculator içerisindeki Count methodu çalıştırılacak. Dolayısıyla bu yaptığımız doğru değil çünkü alt sınıf üst sınıf gibi davranmıyor.</p><p>Aslında çözüm basit. Tek yapmamız gereken her iki sınıf için de düzenleme yapmak:</p><pre>public class SumCalculator<br>{<br>    protected readonly int[] _numbers;<br><br>    public SumCalculator(int[] numbers)<br>    {<br>        _numbers = numbers;<br>    }<br><br>    public virtual int Calculate() =&gt; _numbers.Sum();<br>}</pre><pre>public class EvenNumbersSumCalculator: SumCalculator<br>{<br>    public EvenNumbersSumCalculator(int[] numbers)<br>        :base(numbers)<br>    {<br>    }<br><br>    public override int Calculate() =&gt; _numbers.Where(x =&gt; x % 2 == 0).Sum();<br>}</pre><p>Sonuç olarak, uygulamamızı tekrar çalıştırdığımızda beklediğimiz gibi 18 çıktısını görüyoruz.</p><p>Bu durumu şöyle açıklayabiliriz; Bir alt sınıf değişkeni üst sınıf referansıyla tutuluyorsa Calculate methodunu çağırdığımızda üst sınıfın Calculate methodunu kullanır. Ama yaptığımız düzenlemede Calculate methodu virtual olduğu için alt sınıf bu methodu ezer ve bu methodu kullanmak zorunda kalır.</p><p>Yine de tam olarak LSP uygulamış değiliz. Çünkü bu sefer de üst sınıf alt sınıfın yerini alamıyor. Dolayısıyla Calculator adında bir abstract sınıf eklememiz gerekiyor.</p><pre>public abstract class Calculator<br>{<br>    protected readonly int[] _numbers;<br><br>    public Calculator(int[] numbers)<br>    {<br>        _numbers = numbers;<br>    }<br><br>    public abstract int Calculate();<br>}</pre><p>Daha sonra diğer sınıfları uygun bir şekilde değiştirmemiz gerekiyor.</p><pre>public class SumCalculator : Calculator<br>{<br>    public SumCalculator(int[] numbers)<br>        :base(numbers)<br>    {<br>    }<br><br>    public override int Calculate() =&gt; _numbers.Sum();<br>}</pre><pre>public class EvenNumbersSumCalculator: Calculator<br>{<br>    public EvenNumbersSumCalculator(int[] numbers)<br>       :base(numbers)<br>    {<br>    }<br><br>    public override int Calculate() =&gt; _numbers.Where(x =&gt; x % 2 == 0).Sum();<br>}</pre><p>Uygulamamızı da aşağıdaki şekilde değiştirelim.</p><pre> class Program<br>{<br>    static void Main(string[] args)<br>    {<br>        var numbers = new int[] { 5, 7, 9, 8, 1, 6, 4 };<br><br>        Calculator sum = new SumCalculator(numbers);<br>        Console.WriteLine($&quot;The sum of all the numbers: {sum.Calculate()}&quot;);<br><br>        Console.WriteLine();<br><br>        Calculator evenSum = new EvenNumbersSumCalculator(numbers);<br>        Console.WriteLine($&quot;The sum of all the even numbers: {evenSum.Calculate()}&quot;);<br>    }<br>}</pre><p>Sonuç olarak istediğimiz sonucu elde etmiş olduk. Şimdi LSP tanımına tamamen uyacak şekilde düzenleme yapmış olduk.</p><h4>Interface Segregation Prensibi</h4><p>Bu prensip temel anlamda der ki; hiçbir sınıf kullanmayacağı methodlara sahip olmamalı. Bir sürü farklı açıklama okuyabilirsiniz ama temel anlamda anlatılmak istediği bu.</p><p>Düşünün ki projemize yeni bir özellik ekliyoruz. Kodumuzu yazdık ve bu kod için bir interface oluşturduk. Müşteri, daha sonra yazığımız özelliğe benzer başka bir özellik daha istedi biz de aynı interface’i başka bir sınıfta kullandık. Ancak bu sefer, bu interface’in tüm methodlarına ihtiyacımız yok, yalnızca bazılarına ihtiyacımız var. Bu durumda ihtiyacımız olmayan tüm methodları da implement etmemiz gerekiyor. İşte bu durumda ISP uygulayarak mevcut interface’i küçük parçalara bölerek ihtiyacımız olan kadarını kullanmış oluruz.</p><p>Bu durumu aşağıdaki gibi örnekleyebiliriz.</p><p>Şöyle bir örnek düşünelim; bildiğiniz gibi karada sürülebilen veya uçabilen taşıtlar var aynı zamanda da hem karada sürülebilen hem de uçabilen taşıtlar da var. Dolayısıyla bütün bu fonksiyonaliteyi sağlayan bir kod yapısı kurmamız gerekiyor. Bunun için öncelikte interface’imizi oluşturarak başlayalım:</p><pre>public interface IVehicle<br>{<br>    void Drive();<br>    void Fly();<br>}</pre><p>Şimdi eğer hem uçabilen hem de sürülebilen bir arabamız varsa bu interface işimize yarayacaktır:</p><pre>public class MultiFunctionalCar : IVehicle<br>{<br>    public void Drive()<br>    {<br>        //actions to start driving car<br>        Console.WriteLine(&quot;Drive a multifunctional car&quot;);<br>    }<br><br>    public void Fly()<br>    {<br>        //actions to start flying<br>        Console.WriteLine(&quot;Fly a multifunctional car&quot;);<br>    }<br>}</pre><p>Böylece interface tüm ihtiyaçlarımızı karşıladığını görmüş olduk.</p><p>Şimdi Car sınıfımızı ve Airplane sınıfımızı da oluşturalım:</p><pre>public class Car : IVehicle<br>{<br>    public void Drive()<br>    {<br>        //actions to drive a car<br>        Console.WriteLine(&quot;Driving a car&quot;);<br>    }<br><br>    public void Fly()<br>    {<br>        throw new NotImplementedException();<br>    }<br>}</pre><pre>public class Airplane : IVehicle<br>{<br>    public void Drive()<br>    {<br>        throw new NotImplementedException();<br>    }<br><br>    public void Fly()<br>    {<br>        //actions to fly a plane<br>        Console.WriteLine(&quot;Flying a plane&quot;);<br>    }<br>}</pre><p>Şimdie IVehicle interface’indeki problem açıkça görünüyor. Her sınıf için yalnızca bir methodun doldurulması yeterli oluyor. İhtiyaç olmayan diğer method exception fırlatacak şekilde tasarlanmış. Bu kötü bir fikir çünkü kodu bir amaç için yazıyoruz, exception fırlatması için değil. Ayrıca oluşturduğumuz sınıfın dökümanını yazarken gereksiz methodların kullanılmaması için uyarıda bulunmalıyız.</p><p>Bu kodu aşağıdaki gibi değiştirerek ISP uygulayalım. İlk olarak IVehicle sınıfımızı bölelim:</p><pre>public interface ICar<br>{<br>    void Drive();<br>}</pre><pre>public interface IAirplane<br>{<br>    void Fly();<br>}</pre><p>Sonuç olarak sınıflarımız yalnızca ihtiyacı olan methodları implement eder hale geldi:</p><pre>public class Car : ICar<br>{<br>    public void Drive()<br>    {<br>        //actions to drive a car<br>        Console.WriteLine(&quot;Driving a car&quot;);<br>    }<br>}</pre><pre>public class Airplane : IAirplane<br>{<br>    public void Fly()<br>    {<br>        //actions to fly a plane<br>        Console.WriteLine(&quot;Flying a plane&quot;);<br>    }<br>}</pre><pre>public class MultiFunctionalCar : ICar, IAirplane<br>{<br>    public void Drive()<br>    {<br>        //actions to start driving car<br>        Console.WriteLine(&quot;Drive a multifunctional car&quot;);<br>    }<br><br>    public void Fly()<br>    {<br>        //actions to start flying<br>        Console.WriteLine(&quot;Fly a multifunctional car&quot;);<br>    }<br>}</pre><p>Hatta daha üst bir interface oluşturup tek sınıfın birden fazla interface kullanmasını da sağlayabiliriz:</p><pre>public interface IMultiFunctionalVehicle : ICar, IAirplane<br>{<br>}</pre><pre>public class MultiFunctionalCar : IMultiFunctionalVehicle<br>{<br>    public void Drive()<br>    {<br>        //actions to start driving car<br>        Console.WriteLine(&quot;Drive a multifunctional car&quot;);<br>    }<br><br>    public void Fly()<br>    {<br>        //actions to start flying<br>        Console.WriteLine(&quot;Fly a multifunctional car&quot;);<br>    }<br>}</pre><p>Ya da hazır Car ve Airplane sınıflarını implement etmişken, decorator pattern’ini uygulayarak sınıfımızın içerisinde kullanabiliriz:</p><pre>public class MultiFunctionalCar : IMultiFunctionalVehicle<br>{<br>    private readonly ICar _car;<br>    private readonly IAirplane _airplane;<br><br>    public MultiFunctionalCar(ICar car, IAirplane airplane)<br>    {<br>        _car = car;<br>        _airplane = airplane;<br>    }<br><br>    public void Drive()<br>    {<br>        _car.Drive();<br>    }<br><br>    public void Fly()<br>    {<br>        _airplane.Fly();<br>    }<br>}</pre><h4>Dependency Inversion Prensibi</h4><p>Bu prensipte diyor ki; öyle bir kod tasarlamalıyız ki uygulamamız içerisindeki yüksek-seviye modüller düşük-seviye modüllere bağımlı olmasın abstractionlara bağlı olsun ve düşük-seviye modüllerde yapılacak olan değişikliklerden etkilenmesin. Bu davranışı gerçekleştirmek için yüksek-seviyeli modülleri düşük-seviye modüllerden soyutlamalıyız.</p><p>Peki bu yüksek-seviye ve düşük-seviye modül ne demek?</p><p>Yüksek-seviye modüller doğası gereği daha soyut ve karmaşık mantığa sahip işlemleri temsil eder. Bu modüller düşük-seviye modülleri kullanarak daha karmaşık işleri yürütürler.</p><p>Düşük-seviye modüller daha çok küçük bireysel görevleri halleden modüller olarak düşünülebilir. Bunlar yüksek-seviye modüller tarafından kullanılırlar.</p><p>Hemen DIP’i ihlal eden bir örnekle başlayalım. Öncelikle modellerimizi ve enum’larımızı oluşturalım:</p><pre>public enum Gender<br>{<br>    Male,<br>    Female<br>}</pre><pre>public enum Position<br>{<br>    Administrator,<br>    Manager,<br>    Executive<br>}</pre><pre>public class Employee<br>{<br>    public string Name { get; set; }<br>    public Gender Gender { get; set; }<br>    public Position Position { get; set; }<br>}</pre><p>Devamında, employee kayıtlarını tutan düşük-seviye bir sınıf oluşturalım</p><pre>public class EmployeeManager<br>{<br>    private readonly List&lt;Employee&gt; _employees;<br><br>    public EmployeeManager()<br>    {<br>        _employees = new List&lt;Employee&gt;();<br>    }<br><br>    public void AddEmployee(Employee employee)<br>    {<br>        _employees.Add(employee);<br>    }<br>}</pre><p>Sonrasında employee’ler arasında istatistik analizi yapan yğksek-seviye bir sınıf oluşturalım:</p><pre>public class EmployeeStatistics<br>{<br>    private readonly EmployeeManager _empManager;<br><br>    public EmployeeStatistics(EmployeeManager empManager)<br>    {<br>        _empManager = empManager;<br>    }<br><br>    public int CountFemaleManagers()<br>    {<br>        //logic goes here<br>    }<br>}</pre><p>Göürüldüğü üzere EmployeeManager sınıfının yapısı bu şekilde olduğu sürece EmployeeStatistics içerisinden _employess listesine erişemeyiz. Çözüm olarak bu private listeyi dışarı açmamız gerekiyor:</p><pre>public class EmployeeManager<br>{<br>    private readonly List&lt;Employee&gt; _employees;<br>    <br>    public EmployeeManager()<br>    {<br>        _employees = new List&lt;Employee&gt;();<br>    }<br><br>    public void AddEmployee(Employee employee)<br>    {<br>        _employees.Add(employee);<br>    }<br><br>    public List&lt;Employee&gt; Employees =&gt; _employees;<br>}</pre><p>İşte şimdi Count methodunun kodlarını yazabiliriz:</p><pre>public class EmployeeStatistics <br>{ <br>    private readonly EmployeeManager _empManager; <br>    public EmployeeStatistics(EmployeeManager empManager) <br>    {<br>       _empManager = empManager; <br>    } <br><br>    public int CountFemaleManagers () =&gt; <br>      _empManager.Employees.Count(emp =&gt; emp.Gender == Gender.Female &amp;&amp; emp.Position == Position.Manager);<br> }</pre><p>Bu işlem çalışsa bile istediğimiz kod bu şekilde olmamalı. Bu kod DIP kurallarını ihlal ediyor. Şöyle ki;</p><p>İlk olarakEmployeeStatistics sınıfı ile EmployeeManager sınıfı arasında sıkı sıkıya bağlı bir ilişki var ve EmployeeStatistics constructor’ında EmployeeManager nesnesinden başka bir nesne gönderilemiyor. İkinci olarak düşük-seviye sınıfın public property’sini yüksek seviye bir sınıf içerisinde kullanıyoruz. Bu şekilde olduğu sürece düşük-seviye sınıf employee kayıtlarını saklama mantığında bir değişiklik yapması çok zor olacaktır. Eğer bu kayıtları liste yerine dictionary içerisinde tutmak istersek EmployeeStatistics içerisinde de değişiklik yapmamız gerekecek ve bu bizim istemediğimiz bir durum.</p><p>DIP uygulayarak bu durumdan kurtulabiliriz. Durumu düzeltmek için ilk yapmamız gereken IEmployeeSearchable interface’ini eklemek:</p><pre>public interface IEmployeeSearchable<br>{<br>    IEnumerable&lt;Employee&gt; GetEmployeesByGenderAndPosition(Gender gender, Position position);<br>}</pre><p>Sonrasında EmployeeManager sınıfınında değişiklik yapalım:</p><pre>public class EmployeeManager: IEmployeeSearchable<br>{<br>    private readonly List&lt;Employee&gt; _employees;<br><br>    public EmployeeManager()<br>    {<br>        _employees = new List&lt;Employee&gt;();<br>    }<br>    <br>    public void AddEmployee(Employee employee)<br>    {<br>        _employees.Add(employee);<br>    }<br><br>    public IEnumerable&lt;Employee&gt; GetEmployeesByGenderAndPosition(Gender gender, Position position)<br>        =&gt; _employees.Where(emp =&gt; emp.Gender == gender &amp;&amp; emp.Position == position);<br>}</pre><p>Son olarak EmployeeStatistics sınıfımızı düzenleyelim:</p><pre>public class EmployeeStatistics<br>{<br>    private readonly IEmployeeSearchable _emp;<br><br>    public EmployeeStatistics(IEmployeeSearchable emp)<br>    {<br>        _emp = emp;<br>    }<br><br>    public int CountFemaleManagers() =&gt; <br>    _emp.GetEmployeesByGenderAndPosition(Gender.Female, Position.Manager).Count();<br>}</pre><p>DIP kurallarını uyguladıktan sonra, EmployeeStatistics sınıfının artık düşük-seviye sınıfa bağımlılığı kalkmış oldu ve EmployeeManager sınıfı employee bilgilerini nasıl saklayacağı hakkında istediği değişiklikleri yapabilir.</p><p>Son olarak Program.cs sınıfımızda değişiklik yapıp sonucu görelim:</p><pre>class Program<br>{<br>    static void Main(string[] args)<br>    {<br>        var empManager = new EmployeeManager();<br>        empManager.AddEmployee(new Employee { Name = &quot;Leen&quot;, Gender = Gender.Female, Position = Position.Manager });<br>        empManager.AddEmployee(new Employee { Name = &quot;Mike&quot;, Gender = Gender.Male, Position = Position.Administrator });<br><br>        var stats = new EmployeeStatistics(empManager);<br>        Console.WriteLine($&quot;Number of female managers in our company is: {stats.CountFemaleManagers()}&quot;);<br>    }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/417/0*zUBtPWoz_7SSxVXJ.png" /></figure><p><strong>Dependency Inversion Prensibi’nin Faydaları</strong></p><p>Modüller arası bağımlılıkların azaltılması uygulama oluşturmanın önemli parçalarından biridir. Oluşturduğumuz sınıflar ile düşük-seviye modüllerin arasındaki bağ ne kadar az olursa o kadar tekrar kullanılabilme oranı artar.</p><p>Dolayısıyla DIP’in önemli olmasının ana sebebi uygulama modüllerinin tekrar tekrar kullanılabilmesine olanak sağlamasıdır.</p><p>Tekrar hatırlatmak gerekirse, halihazırda varolan modülleri değiştirmek riskli bir iştir. Gerçek nesneler yerine soyut nesnelere bağımlı olduğumuz sürece düşük-seviye nesnelerde yapacağımız değişiklikler yüksek-seviye nesnelerde değişiklik oluşturmayacaktır.</p><h4>Sonuç</h4><p>Toparlayacak olursak Dependency Inversion Prensibi SOLID prensiplerinin sonuncusuydu. Bu prensiplere uymamanın sonucundan nelerle karşılaşacağımızı görmüş olduk. Artık kodumuzu yazarken bu prensipleri akılda bulundurarak daha iyi ve sağlam projeler geliştirebiliriz.</p><p>Unutmayın, temiz ve düzenli kod yazmak sadece bir yetenek değil aynı zamanda da bir alışkanlıktır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d6c8980a0a93" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ASP.NET Core MediatR ile CQRS Pattern Uygulaması]]></title>
            <link>https://medium.com/@mugrcn/asp-net-core-mediatr-ile-cqrs-pattern-uygulamas%C4%B1-c0dd8217ac89?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0dd8217ac89</guid>
            <category><![CDATA[aspnetcore]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[cqrs]]></category>
            <category><![CDATA[scalability]]></category>
            <category><![CDATA[mediatr]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Thu, 02 Nov 2023 08:21:44 GMT</pubDate>
            <atom:updated>2023-11-09T09:05:56.366Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu yazıda, CQRS pattern’i konusuna giriş yapacağız ve MediatR kütüphanesinin yardımıyla bu mimariyi kurmaya çalışacağız.</p><p>Ayrıca MediatR kütüphanesinin request, notification ve behavior özelliklerini uygulamalı olarak göreceğiz.</p><h3>CQRS ve Mediator Pattern</h3><p>MediatR kütüphanesi iki ana yazılım mimari pattern’ini kolaylaştıran bir kütüphanedir: CQRS ve Mediator pattern. Bu sırada bu pattern’lerin arkasındaki prensipleri anlamaya çalışalım.</p><h3>CQRS</h3><p>CQRS, “Command Query Responsibility Segregation” in kısaltmasıdır. Yani adından da anlaşılacağı üzere command (yazma) ve query (okuma) işlemlerinin sorumluluğunu farklı modellere ayırma işlemidir.</p><p>Genel olarak kullanılan CRUD (Create-Read-Update-Delete) işlemlerini düşünelim, genelde tüm bu dört işlemin hepsinden tek bir veri merkezi sorumludur. CQRS ise bu sorumluluğu ikiye bölüp, birine okuma (query) işlemi diğerine de yazma (command) işlemi sorumluluğunu verir.</p><p>Bunun nasıl çalıştığını aşağıdaki resimde gösterilmektedir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UuWUWZa14dKmVMt8.png" /></figure><p>Gördüğümüz üzere Uygulama okuma ve yazma işlemlerini basitçe ayırıyor. Bu ayırma işleminin nasıl yapılması gerektiği konusunda CQRS bize herhangi bir direktifte bulunmuyor. Aynı uygulama içerisinde basitçe farklı class’lar oluştururak da bunu yapabiliriz (birazdan MediatR ile yapılışını göreceğiz) ya da istersek iki farklı uygulamayı farklı sunucularda çalıştırarak da bu işlemi yapabiliriz, bu karar tamamen bize kalmış. Bu karar ölçekleme ihtiyaçları ve altyapıya göre değişebilir, bu yüzden bu konulara değinmeyeceğiz.</p><p>Kilit noktamız CQRS sistem üretmek, <strong>yalnızca okuma ve yazma işlemlerini ayırmak.</strong></p><h3>CQRS’in Avantajları ve Dezavantajları</h3><h4>Avantajları:</h4><ul><li>Single Responsibility — Command ve Query ‘lerin yalnızca bir görevi vardır. Ya uygulamanın state’ini değiştirirler ya da state’ini dönerler. Bu sayede sorunları bulmak kolaylaşır.</li><li>Decoupling — Command ve Query handler’lar sayesinden tamamen birbirinden ayrılırlar. Bu bize büyük esneklik sağlar.</li><li>Scalability — Okuma ve yazma işlemlerini bölmek uygulamızı veritabanı seviyesinde ölçekleme imkanı tanır. İstersek okuma ve yazma işlemlerini farklı veritabanlarından yaparak ayrı ayrı ölçekleyebiliriz.</li><li>Testability — Command ve Query handler’lar basit olarak tasarlandıkları ve tek iş yaptıkları için kolayca test edilebilirler.</li></ul><h4>Dezavantajları</h4><ul><li>Complexity — CQRS gelişmiş bir pettern olduğu için tam olarak anlamak biraz zaman gerektirebilir. Kod içerisinde birbirine değen parçaları mantıksal olarak çözmek biraz zaman alabilir.</li><li>Learning Curve — Her ne kadar düz bir design pattern olmasına rağmen çoğu yazılımcı prosedürel kod yazdığı için, CQRS tarzı kod yazmak biraz kafa karıştırabilir.</li><li>Hard to Debug — Commands ve Queries handler’ları ile birbirinden ayrıldıkları için, uygulamanın normal akışının dışına çıkarlar. Ve Bu da test yapmayı zorlaştırır.</li></ul><p>Şimdi de benzer bir pattern olan <strong>Mediator</strong> pattern’ini inceleyelim.</p><h3>Mediator Pattern</h3><p>Mediator Pattern ile nesnelerin iletişimi ortak bir noktadan sağlanmakta, nesnelerin birbirleriyle doğrudan iletişime girmesi yerine bir aracıyla iletişime girip haberleşmesini tasarımlamaktadır:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/0*zg4YobYzEjm0SnfR.png" /></figure><p>Yukarıdaki görselde de görüldüğü üzere “SomeService” Mediator a mesajını gönderir, Mediator ise mesaj ile ilgilenmesi için birden fazla servisi çalıştırır. Görüldüğü üzere servis ve handler’lar arasında doğrudan bir bağımlılık yoktur.</p><p>Mediator pattern “loose coupling” sağladığı için bağımlılıklar azalır kod basitleşir ve test etmek kolaylaşır. Başka bir deyişle bir modülün ne kadar az sorumluluğu varsa geliştirmesi ve düzenlemesi o kadar kolaylaşır.</p><h3>ASP.NET Core API içerisinde MediatR Kurulumu</h3><h3>Proje Oluşturma</h3><p>Öncelikle Visual Studio’yu açıp yeni bir ASP.NET Code Web API uygulaması oluşturalım. Adını CqrsMediatrExample olarak belirtelim.</p><h3>Bağımlılıklar</h3><p>Package Manager Console ile MediatR paketini kuralım:<br>PM&gt; install-package MediatR</p><h3>Program class</h3><p>Program.cs dosyasını açalım ve MediatR servisini register edelim.</p><pre>builder.Services.AddMediatR(cfg =&gt; cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));</pre><p>Böylece MediatR kullanıma hazır.</p><h3>Controller</h3><p>Controllers klasörü içerisine “API Controller — Empty” tipinde ProductsController.cs controller’ımızı ekleyelim.</p><p>Şöyle bir controller class’ımız oldu:</p><pre>[Route(&quot;api/products&quot;)]<br>[ApiController]<br>public class ProductsController : ControllerBase<br>{<br>}</pre><p>Bu controller içerisinde IMediatR instance’ımızı başlatacak bir contructor ekleyelim:</p><pre>[Route(&quot;api/products&quot;)]<br>[ApiController]<br>public class ProductsController : ControllerBase<br>{<br>    private readonly IMediator _mediator;<br>    public ProductsController(IMediator mediator) =&gt; _mediator = mediator;<br>}</pre><h3>Data Store</h3><p>Normalde gerçek veritabanı kullanırız ancak bu yazıda veritabanı gibi çalışan fake bir sınıf oluşturacağız ve Product değerlerini bu sınıf yardımıyla değiştireceğiz.</p><p>Bunu yapmadan önce basit bir Product sınıfı oluşturalım:</p><pre>public class Product<br>{<br>    public int Id { get; set; }<br>    public string Name { get; set; }<br>}</pre><p>Şimdi de yeni FakeDataStore sınıfımızı ekleyelim:</p><pre>public class FakeDataStore<br>{<br>    private static List&lt;Product&gt; _products;<br><br>    public FakeDataStore()<br>    {<br>        _products = new List&lt;Product&gt;<br>        {<br>            new Product { Id = 1, Name = &quot;Test Product 1&quot; },<br>            new Product { Id = 2, Name = &quot;Test Product 2&quot; },<br>            new Product { Id = 3, Name = &quot;Test Product 3&quot; }<br>        };<br>    }<br><br>    public async Task AddProduct(Product product)<br>    { <br>        _products.Add(product);<br>        await Task.CompletedTask;<br>    }<br><br>    public async Task&lt;IEnumerable&lt;Product&gt;&gt; GetAllProducts() =&gt; await Task.FromResult(_products);<br>}</pre><p>Burada gerçek veritabanı yerine static products listesi üzerinden işlemlerimizi yapacağız ki bu da yazımızın asıl amacını gerçekleştirmek için yeterli olacaktır.</p><p>Program.cs içerisinde DataStore nesnesini singleton olarak ayarlayalım:</p><pre>builder.Services.AddSingleton&lt;FakeDataStore&gt;();</pre><p>Bunu gerçekleştirdikten sonra uygulamamızı CQRS için düzenleyelim.</p><h3>Commands (Yazma) ve Queries (Okuma) Kısımlarını Ayırma</h3><p>Öncelikle projemizde üç ayrı klasör oluşturalım: “Commands”, “Queries” ve “Handlers” isimleriyle.</p><p>Modellerimizi ayırmak için oluşturduğumuz bu klasörleri bu yazı boyunca kullanacağız. Bu ayırma işlemi farklı şekillerde de yapılabilirdi ancak biz bu yazıda basitçe klasör olarak ayırma yöntemini “in-process” seçiyoruz.</p><h3>MediatR Requests İşlemleri</h3><p>MediatR Requests basit birer request-response tipinde mesajlardır. Bir request bir handler tarafından senkron olarak işlenir (senkron derken request gözüyle senkron denilmek isteniyor, C#’daki async/wait anlamında değil).</p><p>MediatR içerisinde iki türde request vardır. Birincisi değer dönen diğeri dönmeyen.Yani birisi okumalar/queries (değer dönen) diğer yazmalar/commands (değer dönmeyen).</p><p>Burada MediatR requestlerini işlemek için daha önce oluşturmuş olduğumuz FakeDataStore‘u kullanacağız.</p><p>Şimdi de tüm product’ları FakeDataStore üzerinden getiren bir request oluşturalım.</p><h3>GetProductsQuery</h3><p>Bu bir query olduğu için “Queries” klasörüne GetProductsQuery isimli bir sınıf ekleyelim:</p><pre>public record GetProductsQuery() : IRequest&lt;IEnumerable&lt;Product&gt;&gt;;</pre><p>Buradaki GetProductsQuery isimli record IRequest&lt;IEnumerable&lt;Product&gt;&gt; interface’ini implement ediyor. Bunun anlamı, bu request product listesi geriye dönecek demektir.</p><p>Daha sonra query’yi işlemesi için Handlers klasörü içerisinde GetProductsHandler sınıfımızı tanımlayalım:</p><pre>public class GetProductsHandler : IRequestHandler&lt;GetProductsQuery, IEnumerable&lt;Product&gt;&gt;<br>{<br>    private readonly FakeDataStore _fakeDataStore;<br><br>    public GetProductsHandler(FakeDataStore fakeDataStore) =&gt; _fakeDataStore = fakeDataStore;<br><br>    public async Task&lt;IEnumerable&lt;Product&gt;&gt; Handle(GetProductsQuery request,<br>        CancellationToken cancellationToken) =&gt; await _fakeDataStore.GetAllProducts();<br>}</pre><p>Burada biraz olay var, o yüzden biraz açalım konuyu.</p><p>IRequestHandler&lt;GetProductsQuery, IEnumerable&lt;Product&gt;&gt; ‘den türettiğimiz GetProductsHandler isimli bir sınıf oluşturduk. Yani bu sınıf GetProductsQuery isteğini işleyecek ve geriye product listesi dönecek demektir.</p><p>GetProductsHandler sınıfı içerisinde yalnızca FakeDataStore içerisindeki product&#39;ları getirenHandle methodunu implement ediyoruz.</p><h3>Request’imizi Çağırma ve Test Etme</h3><p>Request’imizi çağırmak için ProductsController içerisinde GetProducts() action’ımızı oluşturalım:</p><pre>[HttpGet]<br>public async Task&lt;ActionResult&gt; GetProducts()<br>{<br>    var products = await _mediator.Send(new GetProductsQuery());<br><br>    return Ok(products);<br>}</pre><p>MediatR’a request göndermek bu kadar basit. Gördüğünüz gibi FakeDataStore ‘u controller içerisinde dependency olarak eklemedik ve bu query’nin nasıl işlendiği hakkında hiçbir bilgimiz yok. Bu, Mediator tasarım deseninin prensiplerinden biridir ve bu prensibi MediatR ile burada uygulanmış bir şekilde görebiliyoruz.</p><p>Şimdi her şeyin beklediğimiz gibi çalıştığından emin olalım. İlk olarak, uygulamamızı build ve run etmek için CTRL+F5&#39;e basalım. Sonra Postman’i başlatıp yeni bir istek oluşturalım:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/441/0*AtJZ95TwxSvELG40.png" /></figure><p>Harika! Bu, MediatR’ın doğru çalıştığını kanıtlıyor çünkü gördüğümüz değerler, FakeDataStore tarafından başlatılan değerlerdir. İlk “Query” mizi CQRS’te uyguladık 🙂</p><p>Sonraki bölümde, MediatR isteğinin diğer türü hakkında konuşalım, yani bir değer döndürmeyen “Command”.</p><h3>MediatR Commands</h3><p>İlk “Command”ımızı oluşturmak için, FakeDataStore’umuzu güncelleyen tek bir product alan bir isteği ekleyelim.</p><p>“Commands” klasörümüz içinde, AddProductCommand adında bir record ekleyelim:</p><pre>public record AddProductCommand(Product Product) : IRequest;</pre><p>Bu record tek bir Product property’sine sahip ve IRequest interface’inden türemektedir. Bu sefer IRequest imzasının bir type parametresi olmadığına dikkat edelim. Çünkü herhangi bir değer döndürmüyoruz.</p><p><strong>Not:</strong> Konuyu anlatırken, asıl anlatmak istediğimize odaklanıp basitleştirmek adına, direk olarak Productdomain entity’sini kullanıyoruz. Gerçek dünya uygulamalarında bunu yapmazdık, domain entity’leri API’den gizlemek için DTO’ları kullanırdık.</p><p>Ardından, Handlers klasörümüze handler’ımızı ekleyeceğiz:</p><pre>public class AddProductHandler : IRequestHandler&lt;AddProductCommand&gt; <br>{ <br>    private readonly FakeDataStore _fakeDataStore; <br>        <br>    public AddProductHandler(FakeDataStore fakeDataStore) =&gt; _fakeDataStore = fakeDataStore; <br>        <br>    public async Task Handle(AddProductCommand request, CancellationToken cancellationToken) <br>    {<br>        await _fakeDataStore.AddProduct(request.Product); <br>            <br>        return; <br>    } <br>}</pre><p>IRequestHandler&lt;AddProductCommand&gt; interface’inden türeyenHandler class’ı oluşturuyoruz. Daha önce GetValuesQuery için yaptığımız düzenlemeye benzer. Kısaca şunu diyoruz; bu class AddProductCommand request’i ni işler ve geriye void döner.</p><p>Daha sonra FakeDataStore &#39;a veri ekleyen Handle(AddProductCommand request, CancellationToken cancellationToken) methodunu implemente ettik.</p><h3>Request’i Çağıralım ve Test Edelim</h3><p>Şimdi ProductsController içerisinde Post methodu ekleyerek AddProductCommand çağıralım.</p><pre>[HttpPost]<br>public async Task&lt;ActionResult&gt; AddProduct([FromBody]Product product)<br>{        {<br>    await _mediator.Send(new AddProductCommand(product));<br><br>    return StatusCode(201);<br>}</pre><p>Yine Get method’u ile benzer. Ancak bu sefer, AddProductCommand içerisinde değer set ediyoruz ve herhangi bir değer dönmüyoruz.</p><p>Command işlemini test etmek için tekrardan uygulamamızı çalıştıralım ve Postman’e yeni request’imizi ekleyelim</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/0*8f1nyorzTR4QsFiQ.png" /></figure><p>Testin gerçekten çalışıp çalışmadığını test etmek için, GetAllProducts isteğimizi tekrar çalıştıralım:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/430/0*S8uH75lDvAHs0GN6.png" /></figure><p>Burada, AddProductCommand’ın doğru çalıştığını görmüş olduk. Teoride bu basit gibi görünse de, sadece bir string listesini bellekte güncellediğimiz gerçeğinin ötesine düşünmeye çalışalım. Basit mesaj yapıları aracılığıyla bir veri deposuyla iletişim kuruyoruz ve bunun arka planda nasıl uygulandığını bilmiyoruz. Komutlar ve sorgular farklı veri depolarına işaret edebilir. İsteklerinin nasıl ele alınacağını bilmiyorlar ve umursamıyorlar. Bu noktada artık CQRS + Mediator desenlerini MediatR ile uygulayan tamamen işlevsel bir ASP.NET Core API’ye sahibiz.</p><h3>Değer Dönen Commands</h3><p>Gördüğünüz üzere, POST action’ımız sadece 201 status kodu dönüyor. Bu işlemin başarılı olduğu hakkında client’ı bilgilendirmenin daha iyi yolları da var.</p><p>Ancak bunu yapmak için öncelikle GetProductById action’ımızı oluşturalım.</p><p>Tabiki bunu yapmak için de öncelikle yeni bir query record ekleyelim:</p><pre>public record GetProductByIdQuery(int Id) : IRequest&lt;Product&gt;;</pre><p>FakeDataStore sınıfımıza yeni bir method ekleyelim:</p><pre>public async Task&lt;Product&gt; GetProductById(int id) =&gt; <br>    await Task.FromResult(_products.Single(p =&gt; p.Id == id));</pre><p>Ve yeni bir handler ekleyelim:</p><pre>public class GetProductByIdHandler : IRequestHandler&lt;GetProductByIdQuery, Product&gt;<br>{<br>    private readonly FakeDataStore _fakeDataStore;<br><br>    public GetProductByIdHandler(FakeDataStore fakeDataStore) =&gt; _fakeDataStore = fakeDataStore;<br><br>    public async Task&lt;Product&gt; Handle(GetProductByIdQuery request, CancellationToken cancellationToken) =&gt;<br>        await _fakeDataStore.GetProductById(request.Id);<br>        <br>}</pre><p>Şimdi de controller içerisine yeni bir action ekleyelim:</p><pre>[HttpGet(&quot;{id:int}&quot;, Name = &quot;GetProductById&quot;)]<br>public async Task&lt;ActionResult&gt; GetProductById(int id)<br>{<br>    var product = await _mediator.Send(new GetProductByIdQuery(id));<br><br>    return Ok(product);<br>}</pre><p>Bunu Postman ile test etmek isterseniz:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/435/0*N4ZETqI_XHDFnSgm.png" /></figure><h3>Command’ımızı Değiştirelim</h3><p>AddProductCommand record’umuzu şu şekilde değiştirelim:</p><pre>public record AddProductCommand(Product Product) : IRequest&lt;Product&gt;;</pre><p>Sonra da handler’ı güncelleyelim:</p><pre>public class AddProductHandler : IRequestHandler&lt;AddProductCommand, Product&gt;<br>{<br>    private readonly FakeDataStore _fakeDataStore;<br><br>    public AddProductHandler(FakeDataStore fakeDataStore) =&gt; _fakeDataStore = fakeDataStore;<br><br>    public async Task&lt;Product&gt; Handle(AddProductCommand request, CancellationToken cancellationToken)<br>    {<br>        await _fakeDataStore.AddProduct(request.Product);<br>            <br>        return request.Product;<br>    }<br>}</pre><p>Son olarak da action’ımızı güncelleyelim:</p><pre>[HttpPost]<br>public async Task&lt;ActionResult&gt; AddProduct([FromBody]Product product)<br>{<br>    var productToReturn = await _mediator.Send(new AddProductCommand(product));<br><br>    return CreatedAtRoute(&quot;GetProductById&quot;, new { id = productToReturn.Id }, productToReturn);<br>}</pre><p>Bu kadar değişiklikten sonra, artık post request’imizi gönderebiliriz. Ancak bu sefer yeni ürettiğimiz product bilgilerini hem response body’de hem de header içerisinde Location bilgisiyle görebiliriz:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/681/0*GcjCZ08MlhJZ7W-U.png" /></figure><p>Siz, bu bilgilerle Update ve Delete işlemlerini de kolayca implement edebilirsiniz.</p><p>Bir adım da ileri giderek, bir diğer MediatR işlevi olan “Notifications” konusuna giriş yapalım.</p><h3>MediatR Notifications</h3><p>Şimdiye kadar tek request’in tek bir handler tarafından işlendiğini gördük. Ya bir de tek request’in birden fazla handler tarafından işlenmesini isteseydik?</p><p>Bu noktada notifications devreye giriyor. Bu gibi durumlarda, belirli event’ler oluştuktan sonra birbirinden bağımsız işlemleri tetiklememiz gerekir.</p><p>Örneğin:</p><ul><li>Email gönderme</li><li>Cache temizleme</li></ul><p>Bunları gerçekleştirmek için AddProductCommand akışında güncelleme yapıp bir notification publish edeceğiz ve iki handler tarafından bunların işlenmesini sağlayacağız.</p><p>Gerçek bir email gönderme ve cache temizleme bu yazının kapsamı dışındadır. Bunun yerine yalnızca fake value listesinde bu notification’ın handle edildiğini belirten Name değişikliğini yapsak yeterli olacaktır.</p><h3>FakeDataStore’u güncelleyelim</h3><p>FakeDataStore class’ımızı açalışm ve aşağıdaki method’u ekleyelim:</p><pre>public async Task EventOccured(Product product, string evt)<br>{<br>    _products.Single(p =&gt; p.Id == product.Id).Name = $&quot;{product.Name} evt: {evt}&quot;;<br>    await Task.CompletedTask;<br>}</pre><p>Burada basitçe, product’ın Name bilgisi olan event bilgisi eklenerek değiştiriyoruz.</p><p>Bu düzenlemeden sonra notification ve handler’larımızı oluşturalım.</p><h3>Notification ve Handler’ları Oluşturma</h3><p>Tanımlamak istediğimiz event’i barındıran bir notification mesajı oluşturalım.</p><p>“Notifications” adında yeni bir klasör oluşturalım.</p><p>Bu klasör altına ProductAddedNotification record’unu ekleyelim:</p><pre>public record ProductAddedNotification(Product Product) : INotification;</pre><p>Burada Product property’sine sahip ve INotification’dan türeyen ProductAddedNotification class’ımızı ekliyoruz. Bu, daha önceden gördüğümüz IRequest ‘in aynısıdır, yalnızca Notifications için olanı.</p><p>Şimdi iki handler’ı da ekleyebiliriz:</p><pre>public class EmailHandler : INotificationHandler&lt;ProductAddedNotification&gt;<br>{<br>    private readonly FakeDataStore _fakeDataStore;<br><br>    public EmailHandler(FakeDataStore fakeDataStore) =&gt; _fakeDataStore = fakeDataStore;<br><br>    public async Task Handle(ProductAddedNotification notification, CancellationToken cancellationToken)<br>    {<br>        await _fakeDataStore.EventOccured(notification.Product, &quot;Email sent&quot;);<br>        await Task.CompletedTask;<br>    }<br>}</pre><pre>public class CacheInvalidationHandler : INotificationHandler&lt;ProductAddedNotification&gt;<br>{<br>    private readonly FakeDataStore _fakeDataStore;<br><br>    public CacheInvalidationHandler(FakeDataStore fakeDataStore) =&gt; _fakeDataStore = fakeDataStore;<br><br>    public async Task Handle(ProductAddedNotification notification, CancellationToken cancellationToken)<br>    {<br>        await _fakeDataStore.EventOccured(notification.Product, &quot;Cache Invalidated&quot;);<br>        await Task.CompletedTask;<br>    }<br>}</pre><p>Burada aslında aynı şeyi yapan EmailHandler ve CacheInvalidationHandler adında iki sınıf oluşturduk:</p><ol><li>INotificationHandler&lt;ProductAddedNotification&gt;’dan türeyen ve belirtilen event’i handle edebileceğini gösteren,</li><li>Event oluştuğunda FakeDataStore içerisindeki EventOccured method’unu çağıran</li></ol><p>Gerçek kullanım senaryosunda, bunların farklı şekillerde ele alınması gerekirdirdi ancak amacımız Notifications davranışını gözlemlemek olduğu için durumu basitçe ele aldık.</p><h3>Notification’ı Tetiklemek</h3><p>Şimdi sıra notification’ı gerçekten tetiklemekte.</p><p>ProductsController class’ımızı açalım ve Post methodumuzu düzenleyelim:</p><pre>[HttpPost]<br>public async Task&lt;ActionResult&gt; AddProduct([FromBody]Product product)<br>{<br>    var productToReturn = await _mediator.Send(new AddProductCommand(product));<br>    await _mediator.Publish(new ProductAddedNotification(productToReturn));<br>    return CreatedAtRoute(&quot;GetProductById&quot;, new { id = productToReturn.Id }, productToReturn);<br>}</pre><p>MediatR’a artık AddProductCommand ‘ın yanısıra Publish methodu ile ProductAddedNotification’da gönderiyoruz.</p><p>İstersek bunu AddProductCommand handler’ında yapabilirdik, şimdilik basit olsun diye buraya ekliyoruz.</p><h3>Notifications’ı Test Edelim</h3><p>Yapılan düzenlemelerin çalışıp çalışmadığını görmek için uygulamamızı çalıştıralım ve GetProducts isteğimizi çağıralım:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/441/0*4jQWf3doBuwGYJwu.png" /></figure><p>Beklendiği üzereFakeDataStore constructor’ında eklediğimiz üç satır verimiz bulunmakta.</p><p>Yeni product eklemek için diğer Postman isteğimizi çağıralım.</p><p>Tekrardan GetProducts isteğimizi çağıralım:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/601/0*mSy06ekb8xiQvHli.png" /></figure><p>Beklediğimiz gibi yeni product eklediğimizde her iki event de tetiklendi ve Name bilgisini güncelledi. Örneğimiz her ne kadar uydurma olsa da, istediğimiz sonucu aldık; mesajı üretenin haberi olmadan birden fazla event tetikledik.</p><p>Bunu artırmak istersek basitçe yeni bir handler eklememiz yeterli olacaktır. Notification’ı güncellememize gerek kalmayacaktı. Daha önce değindiğimiz seperation of concerns prensibine uymuş olduk.</p><p>Son olarak da MediatR 3.0 ile birlikte gelen Behaviors konusuna değineceğiz.</p><h3>MediatR Behaviors</h3><p>Uygulamalar oluştururken bir sürü ortak problemle karşılaşırız. Bunlara authorization, validation ve logging konularını sayabiliriz.</p><p>Bu işlemleri tüm handler’lara ayrı ayrı uygulamak yerine Behaviors’ı kullanabiliriz. Behaviors ASP.NET Core middleware ile benzer olarak çalışmaktadır. Request’i alırlar, işlerini yaptıktan sonra kendilerinden sonra gelen katmana iletirler.</p><p>Burada logging işlemi yapan MediatR behavior’unu gerçeklemeye çalışacağız.</p><h3>Behavior’ımızı oluşturalım</h3><p>“Behaviors” adında yeni bir klasör oluşturalım:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/358/0*fjBvJLn_mxYe2TyF.png" /></figure><p>Klasör içerisine LoggingBehavior adında bir class ekleyelim:</p><pre>public class LoggingBehavior&lt;TRequest, TResponse&gt; : IPipelineBehavior&lt;TRequest, TResponse&gt;<br>    where TRequest : IRequest&lt;TResponse&gt;<br>{<br>    private readonly ILogger&lt;LoggingBehavior&lt;TRequest, TResponse&gt;&gt; _logger;<br><br>    public LoggingBehavior(ILogger&lt;LoggingBehavior&lt;TRequest, TResponse&gt;&gt; logger)<br>        =&gt; _logger = logger;<br><br>    public async Task&lt;TResponse&gt; Handle(TRequest request, RequestHandlerDelegate&lt;TResponse&gt; next,<br>        CancellationToken cancellationToken) <br>    {<br>        _logger.LogInformation($&quot;Handling {typeof(TRequest).Name}&quot;); <br><br>        var response = await next(); <br>            <br>        _logger.LogInformation($&quot;Handled {typeof(TResponse).Name}&quot;); <br>            <br>        return response;<br>    }<br>}</pre><p>Bu kod şu şekilde çalışıyor:</p><ul><li>TRequest and TResponse tipinde 2 parametre alan Loggi sınıfımızı tanımlıyoruz ve IPipelineBehavior&lt;TRequest, TResponse&gt; interface’ini implement ediyoruz.</li><li>Daha sonra Handle method’unu implement ediyoruz next() methodunu çağırmadan önce ve sonrasına loglama yapıyoruz.</li></ul><h3>Behavior Register İşlemi</h3><p>Bunun için Program.cs içerisine aşağıdaki satırı ekliyoruz:</p><pre>builder.Services.AddSingleton(typeof(IPipelineBehavior&lt;,&gt;), typeof(LoggingBehavior&lt;,&gt;));</pre><p>Dikkat ederseniz, bu behavior’un tüm generic tiplerle çalışması için &lt;,&gt; parametresini kullanıyoruz.</p><h3>Behavior Test</h3><p>Uygulamamızı çalıştıralım ve Postman’den GetAllProduct isteğimizi yapalım.</p><p>“Output” penceresini açtığımızda aşağıdaki gibi bir log göreceğiz:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/684/0*L3Ef5s-G55ayDeKQ.png" /></figure><p>Gördüğünüz üzere GetProducts query handler işlemi öncesi ve sonrası loglama işlemi yapıldı</p><p>Buradaki en önemli nokta; varolan hiçbir request ve handler’ı değiştirmek zorunda kalmamızdır. Bu şekilde basitçe authorization ve validation işlemlerini uygulamamıza ekleyebiliriz.</p><h3>Sonuç</h3><p>Bu yazıda CQRS ve Mediator pattern’lerinin ASP.NET Core uygulamasında kullanımını inceledik.</p><p>Basit bir monolith’den daha büyük bir uygulamaya evrilecek olan uygulamalar için MediatR güzel bir başlangıç noktası sunuyor. Bize okuma ve yazma işlemlerini ayırmamızı, kodlar arasındaki bağımlılıkları minimuma indirmemizi sağlıyor.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0dd8217ac89" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker’da Mount Tipleri | Volumes, Bind Mounts, Tmpfs vs.]]></title>
            <link>https://medium.com/@mugrcn/dockerda-mount-tipleri-volumes-bind-mounts-tmpfs-vs-f060925dd868?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f060925dd868</guid>
            <category><![CDATA[docker-desktop]]></category>
            <category><![CDATA[docker-volume]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[docker-bind-mounts]]></category>
            <category><![CDATA[docker-storage]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Thu, 13 Apr 2023 13:12:19 GMT</pubDate>
            <atom:updated>2023-04-13T13:13:08.702Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu yazıda Docker içerisinde kullanabileceğimiz mount tiplerini inceleyeceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/1*XWD-8hH0GzkRxu5753Q1iQ.jpeg" /></figure><p>Öncelikle konuya sorunu tarif ederek başlayalım; Default olarak container içerisinde oluşturulan tüm dosyalar “Writable Container Layer” (Yazılabilir Container Katmanı) üzerinde depolanır. Bunun anlamı:</p><ul><li>Container silindiğinde içerisindeki veri de silinir ve eğer başka bir işlem bu veriye ihtiyaç duyuyorsa bu veriyi dışarı çıkarmak zor olabilir.</li><li>Container’ın yazılabilir katmanı container’ın çalıştığı host makinasına bağlıdır. Veriyi başka yere kolayca taşıyamayız.</li><li>Container’ın yazılabilir katmanına yazabilmek için dosya sistemi yönetimi sağlayan <a href="https://docs.docker.com/storage/storagedriver/">storage driver</a>’a ihtiyaç bulunmaktadır. Storage driver Linux kernel’i kullanarak ortak bir dosya yönetim sistemi sağlar. Bu ekstra katman, dosya sistemine direk yazabilen <em>volume </em>‘lere kıyasla performansı düşürür.</li></ul><p>Kısaca özetlemek gerekirse; normalde container silindiğinde container içerisinde oluşturulan veriler de silinir.</p><p>Verilerin kaybolmasını önlemek, dosyaları host makinada tutmak için Docker iki seçenek sunar: <em>volumes</em> ve <em>bind mounts</em></p><p>Aynı zamanda Docker, dosyaları host makinanın RAM’inde tutma seçeneği de sunar. Bu dosyalar persisted (kalıcı) olmaz. Eğer Docker’ı Linux üzerinde çalıştırıyorsanız, dosyaları host makinanın RAM’inde tutmak için <em>tmpfs </em>kullanabilirsiniz. Eğer Docker’ı Windows üzerinde çalıştırıyorsanız, dosyaları host makinanın RAM’inde tutmak için <em>named pipe </em>kullanabilirsiniz.</p><h3>Mount Tipleri</h3><p>Mount tipleri arasındaki farkı görmek, dosyaların Docker host üzerinde nerede yaşadığını görmek için aşağıdaki görseli inceleyebilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/0*FgEkukXIbR3SE-tl.png" /></figure><ul><li><strong>Volumes:</strong> <em>Docker tarafından yönetilen</em> host dosya sisteminin bir parçasında depolanırlar (Linux üzerinde /var/lib/docker/volumes/<strong> </strong>klasörü altında). Docker process’leri dışında process’ler bu veriye müdahale edemez. Docker’da veri kalıcılığı için en iyi yöntem volume kullanmaktır.</li><li><strong>Bind mounts: </strong>Host makina üzerinde <em>herhangi bir yerde</em> depolanırlar. Docker process’leri dışındaki process’ler de bu veriye müdahale edebilirler.</li><li><strong>tmpfs mounts: </strong>Yalnızca host makinanın RAM’inde depolanırlar ve dosya sistemine yazılmazlar.</li></ul><h4>Volumes</h4><p>Docker tarafından oluşturulur ve yönetilirler. docker volume create &lt;volume_name&gt;komutu ile volume oluşturulabilir ya da Docker container veya servis çalıştırılırken oluşturulabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/577/1*-43DsJxPa2TPTCvIKUubcw.jpeg" /><figcaption>Docker Volume Mekanizması</figcaption></figure><p>Ayrıca şu şekilde kullanımı da mevcuttur: --mount type=volume,src=volumename,dst=/container/path</p><p>Bir volume oluşturulduğunda, Docker host içerisinde bir klasörde depolanır (/var/lib/docker/volumes/&lt;volume_name&gt;) Bir container’a volume mount ettiğimizde bu klasör mount edilmiş olur. Bind mounts’da benzer şekilde çalışır ancak volume’ler Docker tarafından yönetildiği için host makinanın çekirdek fonksiyonlarından izole edilmiştir.</p><p>Volume’ler birden fazla container tarafından eşzamanlı olarak kullanılabilirler. Volume’ler hiçbir container tarafından kullanılmıyorsa bile otomatik olarak silinmez ve kullanılabilir durumdadır. Kullanılmayan volumeleri docker volume prune komutu ile silebiliriz.</p><p>Örnek uygulama: myvolume isminde bir volume oluşturalım ardından bir nginx container’ı ayağa kaldıralım. Bu container çalıştırılırken nginx container’ı içerisinde index.html dosyasını içeren klasörü (/usr/share/nginx/html/) daha önceden oluşturmuş olduğumuz myvolume ismindeki volume’e mount edelim. Container içerisinde mount ettiğimiz klasöre myfile.txt isimli bir dosya ekleyip container’ı silip tekrar aynı volume’ü vererek yeni bir container ayağa kaldırdığımızda myfile.txt dosyasının silinmediğini görelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_hvAksFmiEe5jao7IGHOxQ.png" /><figcaption>Volume örneği</figcaption></figure><h4>Bind Mounts</h4><p>Docker’ın ilk çıktığı günden beri mevcuttur. Bind mount’lar volume’lere kıyasla sınırlı fonksiyonaliteye sahiptirler. Bind mount kullanıldığında host makinadaki bir klasör veya dosya container’a mount edilir. Bunu yaparken host makinadaki dosyanın ya da klasörün tam dosya yolu kullanılır. Bu dosyanın veya klasörün host makinasında olmasına gerek yoktur. İhtiyaç durumunda oluşturulur. Docker uygulamaları geliştirirken bind mounts yerine volume kullanmak daha çok önerilir. Bind mount’ları yönetirken Docker CLI komutları kullanamazsınız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/575/1*Cf4sNT_93U9Kktj-ruvXIQ.jpeg" /><figcaption>Bind Mount Mekanizması</figcaption></figure><p>İki şekilde de kullanılabilir: Container çalıştırırken kullandığımız gibi -v ile ya da --mount type=bind,source=/host/path/,target=/container/path şeklinde kullanılabilir.</p><p>Örnek uygulama: Bir ngnix container’ı ayağa kaldırılırken container içerisindeki /usr/share/nginx/html/ klasörünü host makinadaki herhangi bir klasöre (örneğin: c:\docker_data\nginx) klasörüne mount edelim. Container içerisinde mount ettiğimiz klasöre myfile.txt isimli bir dosya ekleyip container’ı silip tekrar aynı bind mount’u vererek yeni bir container ayağa kaldırdığımızda myfile.txt dosyasının silinmediğini görelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N64RU4mJqzNIEsEm1PUCCA.png" /><figcaption>Bind mount örneği</figcaption></figure><h4><strong>tmpfs M</strong>ounts</h4><p>Bir tmpfs mount diskte saklanmaz. Kalıcı olması istenmeyen ya da hassas bilgiler barındıran veriyi saklamak için container çalıştığı sürece kullanılabilir. Örneğin, swarm servisleri <a href="https://docs.docker.com/engine/swarm/secrets/">secrets</a> bilgilerini saklamak için tmpfs mounts kullanırlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/575/1*4_og2NV2Uscom5jnxNOOQA.jpeg" /><figcaption>tmpfs Mount Mekanizması</figcaption></figure><p>Şu şekilde kullanılabilir: --mount type=tmpfs,destination=/app.</p><p>Örnek uygulama: Bir ngnix container’ı ayağa kaldırılırken container içerisindeki /usr/share/nginx/exampleapp/ (henüz varolmayan) klasörünü tmpfs mount edelim. Container içerisinde mount ettiğimiz klasöre myfile.txt isimli bir dosya ekleyip container’ı stop edelim (önceki örneklerde silmiştik, tmpfs mount’lar ram de tutulduğu için sadece durdurma işlemi yapalım) tekrar aynı container’ı start ettiğimizde /usr/share/nginx/exampleapp/ klasörünün silinmediğini ancak myfile.txt dosyasının ram’de tutulduğu için silindiğini görebiliriz. Aynı işlemi stop/start şeklinde değil de pause/unpause şeklinde denediğimizde oluşturduğumuz dosyanın silinmediğini görebiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EQzD57ZTg_LCuu4X7hW5uA.png" /></figure><h4>Named Pipes</h4><p>Bir npipe mount Docker host ve container arasında iletişim kurmak için kullanılabilir. Genel kullanım şekli, container içerisinde third-party arçaları çalıştırmak ve named pipe kullanarak Docker Engine API’sine bağlanmak içindir.</p><blockquote>Kullanım Şekilleri:<br>Bind mounts ve volumes, her ikisi de -v veya --volume flag’i kullanılarak container’a mount edilebilirler ancak kullanılan syntax biraz farklıdır. tmpfs mounts için, --tmpfs flag’i kullanılabilir. Ancak genelde daha anlaşılır olduğu için tüm mount tipleri için --mount flag’i kullanılması önerilir.</blockquote><h3>Volumes Kullanım Senaryoları</h3><p>Volumes en çok tercih edilen mount türüdür. Bazı kullanım senaryoları:</p><ul><li>Birden fazla çalışan container’lar arasında veri paylaşmak için kullanılır. Eğer açık bir şekilde oluşturulmamışlarsa bir container’a mount edildiğinde kendiliğinden oluşturulur. Container durduğunda ya da silindiğinde volume’ler silinmez. Birden fazla container aynı volume’ü eşzamanlı olarak kullanabilirler. Volume’ler yalnızca açıkça silme komutu verdiğinizde silinirler.</li><li>Container verisini local olarak değil de uzaktaki bir host üzerinde ya da cloud üzerinde tutmak istediğinizde kullanabilirsiniz.</li><li>Back up almak, restore etmek ya da veriyi bir Docker hosttan diğerine taşımak istediğinizde kullanılabilir. Volume kullanan container’ları durdurup volume klasörünün backup’ını alabilirsiniz ( örneğin /var/lib/docker/volumes/&lt;volume-name&gt;)</li><li>Docker Desktop üzerinde çalışan uygulamalarınız yüksek performanslı I/O işlemleri gerektiriyorsa kullanılabilir. Volume’ler host makina yerine Linux VM üzerinde depolandığı için okuma ve yazma işlemleri daha hızlı olur.</li></ul><h3>Bind Mounts Kullanım Senaryoları</h3><p>Mümkün oldukça volume’ler tercih edilmelidir. Bazı kullanım senaryoları:</p><ul><li>Host makina ile container’lar arasında configürasyon dosyalarını paylaşmak için kullanılır. Docker /etc/resolv.conf dosyasını her bir container için mount ederek container’ların DNS resolution işlemini bu sayede sağlar.</li><li>Development ortamında derleme gerektirmeyen scriptlerin container tarafından direk olarak kullanılması sırasında kullanılır. Örneğin container üzerinde çalışan bir phyton uygulamanız var ve container’ı durdurup tekrar çalıştırmadan geliştirme yapmaya devam edip uygulamanızın çıktılarını görmeye devam edebilirsiniz.</li></ul><h3>tmpfs Mounts Kullanım Senaryoları</h3><p>tmpfs mounts kalıcı olması istenilmeyen verilen depolanması için kullanılır. Güvenlik gerekçeleri ya da uygulamanız büyük miktarda kalıcı olmayan veri kullanıyorsa performans için tercih edilebilir.</p><h3>Bind Mounts ve Volumes için Bazı İpuçları</h3><ul><li>Container içerisinde içinde klasör veya dosyalar olan bir klasöre, <strong>boş volume</strong> mount edilirse, container içerisindeki dosyalar ve klasörler yeni oluşturulan volume’e kopyalanır. Aynı şekilde bir container başlatırken henüz olmayan bir volume verilirse boş bir volume otomatik olarak oluşturulur.</li><li>Container içerisinde içinde klasör veya dosyalar olan bir klasöre <strong>bind mount veya boş-olmayan volume</strong> mount edildiğinde, container içerisindeki klasör görünmez olur. Bu görünmez dosya ve klasörler silinmez ya da güncellenmez ancak unmount edilene kadar bu görünmez klasöre erişilemez.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f060925dd868" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tasarım Kalıpları — #Circuit Breaker Pattern]]></title>
            <link>https://medium.com/@mugrcn/tasar%C4%B1m-kal%C4%B1plar%C4%B1-circuit-breaker-pattern-da9170817e2e?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/da9170817e2e</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[dot-net-framework]]></category>
            <category><![CDATA[retry-pattern]]></category>
            <category><![CDATA[retry-policy]]></category>
            <category><![CDATA[circuit-breaker]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Sun, 05 Feb 2023 18:48:53 GMT</pubDate>
            <atom:updated>2023-02-05T18:48:53.431Z</atom:updated>
            <content:encoded><![CDATA[<h3>Tasarım Kalıpları — #Circuit Breaker Pattern</h3><p>(Circuit Breaker : Devre Kesici)<br>Bu tasarım kalıbının amacı: <strong><em>Dış servislere ya da kaynaklara bağlanırken oluşan, düzelmesi farklı süreler alabilen hataları gidermektir.</em></strong> Bu sayede, uygulama, hata öncesi duruma hızla geri dönme yeteneği (resiliency) kazanır ve tutarlılığı artar. Özellikle microservis mimarisi kullanan dağıtık uygulamalarda sıkça rastlanılan geçici hataların, sistemin tamamını kötü bir şekilde etkilemesini engellemek için kullanılan bir kalıptır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/938/1*3nxbif5UJ6IxeRF_dPE70g.png" /></figure><h3>Bağlam ve Sorun</h3><p>Bir uygulamanın dış kaynak ve servislere erişen işlemler yaptığı, bulut gibi dağıtık ortamlarda; yavaş network bağlantıları, zaman aşımı (timeout), kaynakların gerekenden fazla tüketilmesi gibi sebeplerden dolayı geçici olarak hata alması çok olasıdır. Bu hatalar genelde kısa sürer ve zaman içinde kendi kendine düzelirler. Bulut uygulamaları, bu gibi durumlara karşı hazırlıklı olmalı ve <a href="https://medium.com/@mugrcn/tasar%C4%B1m-desenleri-retry-pattern-5b2db303a7a6"><strong>Retry kalıbında</strong></a> bahsedilen yöntemler gibi çözümlerle bu hataları gidermeye çalışmalıdır.</p><p>Bununla beraber, bazı beklenmedik hatalar da vardır ki; kolay kolay düzelmez ve düzelmesi çok zaman alır. Bu hatalar, kısmi bağlantı kaybından servisin tamamen durmasına kadar çeşitlilik gösterir. Bu gibi durumlarda, servisin, hatanın düzelmeyeceğini kabullenmek yerine, dış servisi tekrar tekrar çağırmayı deneyerek düzeleceğini beklemesi anlamsızdır.</p><p>Ek olarak, eğer bir servis meşgulse, sistemin bir parçasındaki hata tüm sisteme yansıyarak daha büyük hatalara sebebiyet verebilir. Örneğin, bir servis çağrımında timeout belirlenmeli ve bu süre zarfında işlemi gerçekleştiremezse cevap olarak hata dönmelidir. Ancak, bu yöntem, timeout süresi bitene kadar aynı servisin eş zamanlı çağrımlarının bloklanmasına sebebiyet verebilir. Bu bloklanmış istekler, memory, threadler, veritabanı bağlantıları gibi kritik sistem kaynakları ellerinde tutuyor olabilir. Haliyle bu kaynaklar tükenebilir ve aynı kaynakları kullanmaya çalışan, sistemin alakasız parçaları da bu durumdan hata almaya başlayabilirler. Bu gibi durumlarda, isteğin hiç yapılmadan başarısız olduğu sonucu dönülmesi ve sadece başarılı olacağı düşünüldüğünde isteğin yapılması tercih edilir. Kısa süreli bir timeout bu problemi çözmeye yardım edebilir ancak timeout süresi çoğu zaman başarısız olmasına sebebiyet verecek kadar da kısa olmamalıdır.</p><h3>Çözüm</h3><p>Circuit Breaker kalıbı ile hata alma ihtimali olan bir işlemin, sürekli çağırılmasını engeller, hatanın uzun sürüp sürmeyeceğine karar verirken hatanın düzelmesini beklemeden ya da CPU harcamadan işlemin devam etmesini sağlar. Ayrıca, uygulamanın hatanın çözülüp çözülmediğinin algılamasını sağlar. Eğer hata çözülmüşse, uygulamamız, tekrar servisi çağırmaya başlar.</p><blockquote>Circuit Breaker kalıbının amacı Retry kalıbından farklıdır. Retry kalıbı, uygulamanın, başarılı olacağına inandığı işlemi tekrar çağırmasını sağlar. Circuit Breaker kalıbı ise, uygulamanın, başarılı olmayacağını düşündüğü işlemi çağırmasını engeller. Bir uygulama, Circuit breaker üzerinden Retry kalıbınının işlemi çağırmasını sağlayarak, bu iki kalıbı birlikte kullanabilir. Ancak, retry algoritması, circuit breaker tarafından dönen hatalara karşı duyarlı olmalı ve eğer circuit breaker hatanın geçici olmadığını söylerse tekrar deneme çalışmasını sona erdirmelidir.</blockquote><p>Circuit breaker, başarısız olacak işlemler için proxy gibi davranır. Bu proxy daha önce olan hataların sayısını gözlemlemeli ve bu bilgiyi, ilgili işlemin çağrımına izin vermeye ya da hiç beklemeden hata dönmeye karar vermekte kullanmalıdır.</p><p>Bu proxy, elektrik devre kesicinin fonksiyonalitesini taklit eden aşağıdaki durumları gerçekleştiren bir <a href="https://tr.wikipedia.org/wiki/Sonlu_durum_makinesi">durum makinesi</a> (<em>state machine</em>) olarak tasarlanmalıdır:</p><ul><li><strong>Closed (Kapalı): </strong>Uygulamadan gelen istek doğrudan işleme yönlendirilir. Proxy, önceki hataların sayısını kayıt altında tutar ve eğer işlem çağrımı başarısız olursa hata sayısını artırır. Eğer önceki hataların sayısı belirli bir zaman aralığında belirli bir eşik değerini geçerse, proxy <strong>Open (Açık) </strong>duruma geçer. Proxy, bu aşamada timeout zamanlayıcısını başlatır ve bu zamanlayıcı dolduğunda <strong>Half-Open (Yarı-Açık) </strong>duruma geçer.</li><li><strong>Open (Açık):</strong> Uygulamadan gelen istek, hiç beklemeden başarısız kabul edilir ve uygulamaya hata döndürülür.</li><li><strong>Half-Open (Yarı-Açık): </strong>Uygulamadan gelen isteklerin kısıtlı sayıdaki kısmının, işlemi çağırmasına izin verilir. Eğer bu istekler başarılı ise, daha önceki başarısızlığa sebep olan hatanın düzeldiği düşünülür ve proxy tekrardan Closed durumuna geçer. (Hata sayacı sıfırlanır.) Eğer herhangi bir istek hata alırsa, hatanın devam ettiği düşünülerek proxy Open durumuna geçer ve sistemin kendini düzeltmesine zaman tanımak için timeout zamanlayıcısını tekrar başlatır.</li></ul><blockquote><strong>Yarı-Açık</strong> durumu, iyileşmekte (recover) olan servisin, yeni yapılacak isteklerle bir anda boğuşmasını engeller. Servis iyileşmeye çalışırken, iyileşme tamamlanana kadar belirli sayıda istek alabilir, ancak iyileşme tamamlanana kadar sürekli istek yapmak, servisi tekrar cevap veremez hale getirebilir.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/1*niFCwDe2ayLrvdpgDtP0xw.png" /><figcaption>Circuit Breaker durumları</figcaption></figure><p>Dikkat ederseniz, <strong>Kapalı</strong> durumunda kullanılan hata sayacı zaman-bazlıdır. Periyodik aralıklarla sıfırlanır. Bu circuit breaker’ın, ara sıra hata aldığı durumlarda <strong>Açık</strong> durumuna geçmesini engeller; hata sayacı ancak belirtilen aralıkta alınan hata sayısına ulaştığında circuit breaker’ı <strong>Açık</strong> durumuna getirir. <strong>Yarı-Açık</strong> durumunda kullanılan başarı sayacı servisi çağırırken aldığımız başarı sayısını kaydeder. Circuit breaker belirlenen sayıda ardışık başarılı sonuca ulaşırsa <strong>Kapalı</strong> duruma geçer. Herhangi bir hata alınması durumunda circuit breaker hemen <strong>Açık</strong> duruma geçer ve <strong>Yarı-Açık</strong> durumuna geçtiğinde ise başarı sayacı sıfırlanır.</p><p>Circuit breaker kalıbını uygulamak, sisteme tutarlılık ve kendi kendine iyileşebilme yeteneği kazandırır. Hata alacağı bilinen işlemin, timeout almasını (ya da hiç bir zaman dönüş yapmayacak) beklemek yerine anında işlemi yapmayı reddederek, sistemin cevap verme süresini kısaltır. Circuit breaker, durumunu her güncellediğinde event fırlatılırsa, bu bilgi circuit breaker tarafından korunan sistemin sağlığını gözlemlemekte ya da her <strong>Açık</strong> duruma geldiğinde bir sistem yöneticisini uyarmakta kullanılabilir.</p><p>Bu kalıp, hatanın çeşidine göre ayarlanabilir. Örneğin, timeout zamanlayıcısı için artan süreler kullanılabilir. Circuit breaker başlangıçta birkaç saniyeliğine Open durumunda bırakılıp, daha sonrasında hata düzelmezse timeout zamanlayıcısının süresi birkaç dakikaya yükseltilebilir.</p><h3>Sorunlar ve Dikkat Edilmesi Gereken Noktalar</h3><p>Bu kalıbı nasıl kullanacağınıza karar verirken aşağıdaki noktaları da dikkate almalısınız:</p><ul><li><strong>Exception Handling.</strong> Circuit breaker üzerinden istek yapan bir uygulama, işlemin başarısız olması durumunda oluşacak exception’ları handle edebilmelidir. Bunların handle edilme şekli, uygulama özelinde olmalıdır. Bir uygulama geçici olarak fonksiyonalitesini azaltabilir, aynı işi yapacak ya da aynı veriyi elde edecek alternatif yolları kullanabilir, ya da hatayı kullanıcıya bildirir ve daha sonra tekrar denemesini isteyebilir. Örneğin, veritabanı olarak SQL Server kullanan bir uygulamamız olsun ve il, ilçe verisini Redis üzerinde cache’lediğimizi düşünelim. Redis servisi erişilemez olduğu durumda bu veriyi temin etmek için sorun giderilene kadar SQL Server veritabanı kullanabiliriz.</li><li><strong>Exception Tipleri. </strong>Bir istek çok farklı sebeplerden dolayı başarısız olabilir, bazı hata tipleri diğerlerinden çok daha önemli olabilir. Circuit breaker, exception tipine göre strateji belirlenmelidir. Örneğin, circuit breaker’ın <strong>Açık </strong>durumuna geçme sabebi olarak bir sayı limiti belirlemek istersek, timeout exception’larının sayısı, servisin tamamen erişilemez olmasından kaynaklı exception sayısından çok daha fazla olmalıdır.</li><li><strong>Loglama.</strong> Tüm hatalar (mümkünse tüm başarılı işlemler de) loglanmalıdır ki sistem yöneticisi işlemin sağlıklı çalışıp çalışmadığını gözlemleyebilsin.</li><li><strong>İyileşme Yeteneği.</strong> Circuit breaker koruduğu işlemin iyileşme tarzına ayak uyduracak şekilde ayarlanmalıdır. Eğer circuit breaker uzun süre <strong>Açık</strong> durumunda kalırsa, koruduğu işlem çoktan normale döndüğü halde hata fırlatmaya devam eder. Aynı şekilde, hızlıca <strong>Açık </strong>durumundan <strong>Yarı-Açık</strong> duruma geçerse uygulamanın cevap verme süresini kısaltabilir.</li><li><strong>Başarısız İşlemleri Test Etme.</strong> <strong>Açık</strong> durumdayken, ne zaman <strong>Yarı-Açık</strong> duruma geçeceğini bilmek için zamanlayıcı kullanmak yerine, belirli aralıklarla ilgili servise ping atmayı deneyebilir. Bu ping’in şekli başarısız olan işlemin aynısı da olabilir ya da karşıdaki servis tarafından sunulan health endpoint’i kullanarak da olabilir.</li><li><strong>Dışarıdan Müdahale.</strong> Hata alan bir işlemin yeniden eski haline gelme süresi çok değişkendir. O yüzden, sistem yöneticisine dışarıdan müdahale yapabileceği, devreyi kapalı duruma getirebileceği (hata sayacını sıfırlayabileceği) bir arayüz sunulmalıdır. Aynı şekilde, circuit breaker tarafından korunan işlem geçici olarak erişilemez duruma geldiğinde devreyi açık duruma getirebileceği (timeout zamanlayacısını sıfırlayabileceği) bir arayüz de sunulmalıdır.</li><li><strong>Concurrency (Eş zamanlı erişim). </strong>Aynı circuit breaker, bir uygulamanın birden fazla instance’ı tarafından aynı anda erişilmek istenebilir. Bu durumda eş zamanlı istekler bloklanmamalı ve işlem çağrımına ekstra yük getirmemelidir.</li><li><strong>Kaynak Ayırt Etmek.</strong> Tek tipte kaynak için tekil bir cicuit breaker kullanırken, eğer birden fazla kaynak sağlayıcı (provider) varsa, buna dikkat edilmelidir. Birden fazla shard’dan (veriyi fiziksel olarak bölmek) oluşan bir veri kaynağında, bir shard tamamen sağlıklıyken diğer shard sorunlu olabilir. Her iki kaynağa da aynı davranılması durumunda, uygulama, hata alması kesin olan shard’a bağlanmayı deneyebilir ya da hata almayan shard’lara erişmeyi bloklayabilir.</li><li><strong>Hızlandırılmış Circuit Break.</strong> Bazen başarısız cevaplar, circuit breaker’ın hemen durumunu değiştirmesi için yeterli bilgiye sahip olabilir. Örneğin, aşırı derecede yoğun çalışan paylaşımlı bir kaynaktan gelen hata cevabı, hemen tekrar denemek yerine birkaç dakika beklenmesi gerektiği anlamına gelebilir.</li><li><strong>Hata Alan İstekleri Yeniden Çağırmak.</strong> <strong>Açık</strong> durumdayken hızlıca hata vermek yerine, bu istekler kayıt altına alınıp sıralanarak, uzaktaki servis aktif duruma geldiğinde bu istekler yeniden çağrılabilir.</li><li><strong>Dış Kaynaklar için Belirlenen Timeout Sürelerinin Uygunsuz Olması.</strong> Hata alan bir işlemin cevap vermesi için belirlenen timeout süreleri bazen yanlış olabilir. Eğer timeout çok uzun verilmişse, circuit breaker’ı çalıştıran thread hata alacak bir işlemi beklerken bloklanabilir. Bu süre zarfında, aynı isteği circuit breaker üzerinden çalıştırmak isteyen diğer uygulamalarda kullandıkları thread’leri gereksiz yere meşgul ederler.</li></ul><h3>Ne Zaman Kullanmalı?</h3><p>Bir uygulamanın, hata alma ihtimali yüksek olan bir dış servisi ya da kaynağı çağırmasını önlemek için kullanılır.</p><h3>Ne Zaman Kullanmamalı?</h3><ul><li>Uygulama içerisindeki bir kaynağa (örneğin ön bellekte duran bir kaynak için) erişmeye çalışırken. Bu durum sisteme gereksiz bir yük getirir.</li><li>Uygulamanızı iş mantığındaki exception’ları handle ederken.</li></ul><h3>Örnek</h3><p>Bir web uygulamasında, bir sürü sayfa dış servis ile erişilen veriden oluşur. Eğer sistem, cache verisini düşük tutarsa, sayfalara gelen çoğu istek bu servise erişmek isteyecektir. Web uygulamasından bu dış servise yapılan istekler için bir timeout süresi belirlenmelidir (örneğin 60 saniye), ve eğer servis bu süre içerisinde cevap vermezse, bu sayfalar belirtilen servise erişimin olmadığını düşünerek hata fırlatacaklardır.</p><p>Bununla beraber, eğer bu servis hata alır ve çok meşgulse, kullanıcılar bir hata alana kadar 60 saniye beklemek zorunda kalacaklar. Sonuç olarak, memory, bağlantılar ve threadler, bu dış servisten veri çekemedikleri halde dolacak ve diğer kullanıcıların sisteme erişmesini engelleyeceklerdir.</p><p>Yeni sunucular ekleyip yük dağılımı yapsak bile, bir süre sonra bu sunucuların da kaynakları tükenecek ve onlarda cevap veremez duruma geleceklerdir.</p><p>Dış kaynağa yapılan istekleri circuit breaker üzerinden yaptığımızda bu sorunların giderilmesine yardım edecektir. Kullanıcı istekleri hala hata alacak ama daha çabuk hata alacaklar bu sayede kaynaklar bloklanmayacaktır.</p><p>CircuitBreaker class’ı durum bilgisini, aşağıdaki gösterilen ICircuitBreaker interface’ini implemente eden circuit breaker nesnesi içerisinde tutar.</p><pre>interface ICircuitBreakerStateStore<br>{  <br>    CircuitBreakerStateEnum State { get; }  <br>    Exception LastException { get; }  <br>    DateTime LastStateChangedDateUtc { get; }<br>    bool IsClosed { get; }<br>    <br>    void Trip(Exception ex);  <br>    void Reset();  <br>    void HalfOpen();<br>}</pre><p><strong>State</strong> değeri içerisinde circuit breaker’ın o anki durumu saklanır ve bu değer <strong>CircuitBreakerStateEnum</strong> içerisinde tanımlı, <strong>Open</strong>, <strong>Half-Open</strong> veya <strong>Closed</strong> değerlerinden biri olabilir. Eğer circuit breaker kapalıysa <strong>IsClosed</strong> değeri true olmalı ama açık veya yarı-açık ise false olmalıdır. <strong>Trip</strong> metodu circuit breaker’ı açık duruma getirir ve durumu değiştiren exception’ı gün ve saat bilgisiyle kaydeder. <strong>LastException</strong> ve <strong>LastStateChangedDateUtc</strong> değerleri bu bilgiyi döner. <strong>Reset </strong>metodu circuit breaker’ı kapatır ve <strong>HalfOpen </strong>metodu ise circuit breaker’ı yarı-açık durumuna getirir.</p><p>Örnekteki <strong>InMemoryCircuitBreakerStateStore</strong> sınıfı <strong>ICircuitBreakerStateStore</strong> interface’ini implemente eder. <strong>CircuitBreaker</strong> sınıfı, circuit breaker’ın durumunu saklamak için bu nesneden bir tane yaratır.</p><p><strong>CircuitBreaker </strong>sınıfındaki <strong>ExecuteAction </strong>metodu, hata alabilecek işlemi <strong>Action </strong>delegesi olarak alır. Bu metod çalıştığında ilk olarak circuit breaker’ın durumunu kontrol eder. Eğer kapalıysa (<strong>IsOpen</strong> değişkeni) <strong>ExecuteAction</strong> methodu <strong>Action</strong> delegesi olarak verilen işlemi çağırır. Eğer işlem başarısız olursa <strong>TrackException</strong> metodu çağrılır. Bu method <strong>InMemoryCircuitBreakerStateStore</strong> nesnesindeki <strong>Trip</strong> metodunu çağırarak circuit breaker’ı açık duruma getirir. Aşağıdaki örnek kod, bu akışın nasıl olduğu gösteriyor.</p><pre>public class CircuitBreaker<br>{  <br>    private readonly ICircuitBreakerStateStore stateStore = <br>            CircuitBreakerStateStoreFactory.GetCircuitBreakerStateStore();  <br>    private readonly object halfOpenSyncObject = new object ();<br>    ...<br>    public bool IsClosed { get { return stateStore.IsClosed; } }  <br>    public bool IsOpen { get { return !IsClosed; } }  <br>    public void ExecuteAction(Action action)  <br>    {<br>        ...    <br>        if (IsOpen)<br>        {      <br>            // Circuit breaker açıksa<br>            ... (detaylar için aşağıdaki örnek kodu inceleyiniz)<br>        }<br><br>        // Circuit breaker kapalıysa işlemi yap<br>        try<br>        {<br>            action();<br>        }<br>        catch (Exception ex)<br>        {<br>            // Eğer burada bir hata oluşursa, hemen<br>            // re-trip yapılır.<br>            this.TrackException(ex);      <br>            // Hata fırlatılır, böylece işlemi çağıran kısım<br>            // hangi tipte hata aldığını iletebilir.      <br>            throw;    <br>        }<br>    }<br><br>    private void TrackException(Exception ex)  <br>    {<br>        // Bu örnekte basit olsun diye, alınan ilk hatada<br>        // circuit breaker Açık duruma geçti.<br>        // Ama gerçekte bu biraz daha karışık olabilir.<br>        // Servisin offline olduğunu belirten tipte bir exception,<br>        // circuit breaker&#39;ı hemen açık duruma getirebilir.<br>        // Aynı şekilde oluşan hataların sayısına göre veya<br>        // hata/başarı oranına göre karar verilip açık duruma getirilebilir.<br>        this.stateStore.Trip(ex);  <br>    }<br>}</pre><p>Sıradaki örnek kod (bir önceki örnekten çıkarılan), circuit breaker’ın kapalı <em>olmaması</em> halinde çalışacak kodu gösteriyor. İlk önce, circuit breaker’ın, <strong>CircuitBreaker</strong> sınıfındaki <strong>OpenToHalfOpenWaitTime</strong> alanında belirlenen süreden daha uzun bir süredir açık durumda olup olmadığı kontrol edilir. Öyleyse <strong>ExecuteAction</strong> metodu circuit breaker’ı yarı açık duruma getirir sonra <strong>Action</strong> delegesindeki işlemi çağırır.</p><p>Eğer işlem başarılı olursa, circuit breaker kapalı duruma geçer. İşlem başarısız olursa tekrar açık duruma geçer ve exception bilgisi güncellenir ve işlemi tekrar çağırabilmek için daha uzun bir süre bekletilir.</p><p>Eğer circuit breaker <strong>OpenToHalfOpenWaitTime</strong> değerinden daha kısa bir süredir beklemişse, <strong>ExecuteAction</strong> metodu direk <strong>CircuitBreakerOpenException</strong> tipinde bir exception fırlatır ve açık duruma gelmesine sebep olan kayıtlı hatayı da içerir.</p><p>Aynı zamanda circuit breaker’ın yarı-açık konumdayken eş zamanlı çağrımlarını önlemek için <strong>lock</strong> kullanılır Eş zamanlı çağrımlara, circuit breaker açık durumdayken bakılır ve daha sonra açıklayacağımız şekilde exception ile sonuçlanır.</p><pre>...<br>    if (IsOpen)<br>    {<br>        // Circuit breaker açık. Açık timeout&#39;u dolmuş mu kontrol et.<br>        // Dolmuşsa, durumu yarı-açık yap.<br>        if (stateStore.LastStateChangedDateUtc + OpenToHalfOpenWaitTime <br>              &lt; DateTime.UtcNow)<br>        {<br>            // Açık timeout&#39;u dolmuş. Bir işlemin çalışmasına izin ver.<br>            // Dikkat edin bu örnekte, circuit breaker belirli bir süre<br>            // Açık konumda kaldıktan sonra hemen Yarı-Açık duruma geçti.<br>            // Burada ihtiyacınız olan farklı yöntemler kullanılabilir.<br>            // Yarı-açık durumundayken çalıştırılacak thread sayısı sınırlandırılır.<br><br>            bool lockTaken = false;<br>            try<br>            {<br>                Monitor.TryEnter(halfOpenSyncObject, ref lockTaken)<br>                if (lockTaken)<br>                {<br>                    // Circuit breaker Yarı-açık duruma getirilir.<br>                    stateStore.HalfOpen();            <br>                    // İşlem çalıştırılır.<br>                    action();            <br>                    // Eğer bu işlem başarılı olmuşsa sayaçlar sıfırlanır.<br>                    // Diğer işlemlerin çalışmasına izin verilir.<br>                    // Gerçekte, hemen Açık durumdan dönülmez,<br>                    // başarılı işlem sayıları kaydedilir ve<br>                    // belirlenen sayıda başarılı işlem tamamlanırsa dönülür.<br>                    this.stateStore.Reset();            <br>                    return;          <br>                }          <br>            catch (Exception ex)          <br>            {<br>                // Eğer hala hata varsa devre kesilir.<br>                this.stateStore.Trip(ex);            <br>                // Çağıran&#39;ın exception bilgisini alması için fırlatılır.<br>                throw;          <br>            }          <br>            finally          <br>            {<br>                if (lockTaken)<br>                {<br>                    Monitor.Exit(halfOpenSyncObject);            <br>                }          <br>            }        <br>        }      <br>    }<br>    // Açık durum zamanlayıcısı henüz dolmamış ise,<br>    // Çağıranı bilgilendirme amaçlı, CircuitBreakerOpenException tipinde ve<br>    // son exception bilgilerini de içeren bir exception fırlatılır.<br>    throw new CircuitBreakerOpenException(stateStore.LastException);<br>        <br>}<br>    ...</pre><p>Bir işlemi korumak için <strong>CircuitBreaker</strong> nesnesi kullanırken, uygulama tarafından CircuitBreaker sınıfından bir nesne yaratılır ve asıl işlem ExecuteAction metoduna parametre olarak verilerek çağrılması sağlanır. Uygulama CircuitBreakerOpenException hatası almaya hazırlıklı olmalıdır. Aşağıdaki kod bunun bir örneğidir:</p><pre>var breaker = new CircuitBreaker();<br>try<br>{  <br>    breaker.ExecuteAction(() =&gt;  <br>    {    <br>        // Circuit breaker tarafından korunan işlem<br>        ...  <br>    });<br>}<br>catch (CircuitBreakerOpenException ex)<br>{  <br>    // Circuit breaker açıksa farklı bir işlem yapılabilir.<br>    // Son exception detayları inner exception içerisinde yer almaktadır.<br>    ...<br>}<br>catch (Exception ex)<br>{  <br>    ...<br>}</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da9170817e2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tasarım Desenleri — #Retry Pattern]]></title>
            <link>https://medium.com/@mugrcn/tasar%C4%B1m-desenleri-retry-pattern-5b2db303a7a6?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/5b2db303a7a6</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[retry-pattern]]></category>
            <category><![CDATA[resilience]]></category>
            <category><![CDATA[retry-policy]]></category>
            <category><![CDATA[csharp]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Sun, 29 Jan 2023 09:41:50 GMT</pubDate>
            <atom:updated>2023-01-29T21:00:17.566Z</atom:updated>
            <content:encoded><![CDATA[<h3>Tasarım Kalıpları — #Retry Pattern</h3><p>(Retry : Tekrar deneme)<br>Bu tasarım kalıbının amacı: Bir uygulamanın, bir servise veya network kaynağına bağlanmaya çalışırken hata alması durumunda, bu hatanın geçici olduğu düşünülürse, <em>arka planda aynı işlemi tekrar deneyerek</em>, sorunu farkettirmeden gidermeye çalışmak. Bu tasarım kalıbı ile uygulamanın tutarlılığı artırılır.</p><h3>Bağlam ve Sorun</h3><p>Bulut üzerinde çalışan sistemlerle iletişim kuran bir uygulamanın, geçici hatalarla karşılaşması büyük olasıdır. Bu hatalar, bağlı bulunulan servis ve bileşenler arasındaki anlık network erişimi kaybı, servisin geçici olarak durması, servis meşgulken timeout hatası alınması gibi hatalar olabilir.</p><p>Bu tipteki hatalar, genelde kendi kendine düzelen ve hataya sebep olan aksiyon, yeteri kadar beklenildikten sonra tekrar tetiklenirse, başarıyla çalışması yüksek ihtimal olan hatalardır. Örneğin, bir veritabanı servisi, aynı anda çok sayıda istek alırsa, iş yükü hafifleyene kadar cevap vermeyi reddedebilir. Böyle durumlarda veritabanına erişmeye çalıştığımızda hata alabiliriz, ancak bir süre bekleyip tekrar denediğimizde, isteğimize başarılı olarak cevap alabiliriz.</p><h3>Çözüm</h3><p>Bulut üzerinde çalışan sistemlerin, kısa süreli hatalarla karşılaşma olasılığının farkında olup, bunları arka planda, fark ettirmeden, uygulama üzerindeki etkilerini minimize edecek şekilde ele alması gerekir.</p><p>Eğer bir uygulama, uzaktaki bir servisi çağırırken hata ile karşılaşırsa, hatayı aşağıdaki yöntemlerle ele alabilir:</p><ul><li><strong>Eğer hata geçici değilse veya tekrar denendiğinde başarılı olmayacağı kesin ise</strong> (örneğin, login olma işleminde hatalı kullanıcı adı veya şifre belirtilmişse kaç kere denenirse denensin başarılı olamayacaktır) , uygulamamız <strong>işlemi bitirmeli</strong> ve uygun bir exception dönmeli.</li><li><strong>Eğer hata, nadir karşılaşılan, normalde beklemediğimiz bir hata ise,</strong> mesela başka bir servisle uygulamamız arasında iletilen network paketlerinde bozulmadan kaynaklı olabilir. Bu durumda, uygulamamız, <strong>isteği anında tekrarlarsa</strong> büyük bir olasılıkla aynı hata ile karşılaşmayacaktır.</li><li><strong>Eğer hata, genel bir bağlantı ya da “meşgul olma” hatası ise,</strong> network ya da servisin, bağlantı problemini düzeltmesi veya birikmiş işleri bitirmesi için kısa bir süreye ihtiyacı var demektir. Bu durumda, uygulamamız <strong>belirli bir süre bekledikten sonra isteği tekrarlamalıdır</strong>.</li></ul><p>Daha yaygın olan geçici hatalar için, tekrarlar (retry) arası süreler, mümkün olduğunca, uygulamanın birden fazla instance’larıyla paylaşılmalıdır. Bu sayede meşgul durumdaki servisin aşırı yüklenmesinin önüne geçilir. Aynı uygulamanın birbirinden haberi olmayan diğer instance’ları, sürekli olarak aynı servisi topa tutarsa, istek attığımız servisin toparlanması daha uzun zaman alacaktır. Yani uygulamanın bir instance’ı retry süresini uzatırsa diğer instance’larda bu süreyi uzatmalıdır.</p><p>Eğer istek hala hata alırsa, uygulama bekleme süresini artırıp tekrar deneyebilir. Gerekirse, maximum deneme sayısına ulaşana kadar, bekleme süreleri artırılarak tekrar deneme yapılmalıdır. Bekleme süreleri, hatanın çeşidine göre, sabit ya da üstel (<a href="https://en.wikipedia.org/wiki/Exponential_backoff">exponansiyel</a>) olarak artırılabilir.</p><p>Aşağıdaki resimde, bu yöntem görselleştirilmiştir. Eğer, isteğimiz, belirlediğimiz sayı kadar tekrardan sonra hala başarılı değilse, bu durum artık exception olarak muamele görür ve ona uygun bir şekilde ele alınır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/608/1*T6wAsVUGNrmQQehsvEIGXg.png" /></figure><p>1 - Uygulama servise istek atar. İstek hata alır, ve servis HTTP 500 koduyla (internal server error) cevap verir.<br>2 - Uygulama kısa bir süre bekler ve tekrar dener. İstek hala hata alır ve servis HTTP 500 koduyla cevap verir.<br>3 - Uygulama daha uzun bir süre bekler ve tekrar dener. İstek başarılı bir şekilde, HTTP 200 koduyla cevap verir.</p><p>Uygulama, yukarıda belirtilen tekrarlama yöntemlerinden biriyle, servise erişmek için kullanılan kodu sarmalamalıdır(wrap). Farklı servislere yapılan istekler, farklı yöntemleri gerektirebilir, ve bu yaklaşımları içeren kütüphaneler kullanılabilir. Bu kütüphaneler belirtilen yöntemleri kullanırken verilen parametrelere göre çalıştırılabilir ve yazılımcı bu parametrelerle tekrar deneme sayısını ve bu denemeler arası bekleme sürelerini belirleyebilir.</p><p>Hataları tespit edip, tekrar deneme işlemi gerçekleştiren bu kodlar, bu hataların detaylarını loglamalıdır. Bu bilgi faydalı olabilir. Eğer bir servis sürekli olarak meşgul ya da erişilemez duruma geliyorsa, genelde kaynaklarını tüketmiş demektir. Bu durumda, hata üreten servisi, yatay ölçeklendirme yaparak hataları azaltabiliriz. Örneğin, eğer bir veritabanı servisi, sürekli olarak aşırı yüklenme durumuna düşüyorsa, veritabanı partition yapılarak yükü birden çok sunucuya dağıtabiliriz.</p><h3>Sorunlar ve Değerlendirilmesi Gereken Noktalar</h3><p>Bu tasarım kalıbını nasıl uygulayacağınıza karar verirken değerlendirmeniz gereken noktalar:</p><ul><li><strong>Tekrar deneme yöntemi, uygulamanın iş gereksinimlerine ve hatanın tipine göre ayarlanmalı.</strong> Bazı kritik olmayan işlemlerde tekrar denemek yerine hemen hata vermek daha iyi olabilir, böylece uygulamanın iş çıkarma yeteneği artabilir. Örneğin, uzaktaki bir servise erişmeye çalışan, kullanıcı etkileşimli bir web uygulamasında, az sayıda ve düşük tekrar deneme bekleme sürelerinden sonra hata vermek ve kullanıcıya uygun bir mesaj göstermek (örneğin, “daha sonra tekrar deneyin”), uygulamayı cevap veremez duruma getirmekten kurtarabilir. Toplu iş yapan uygulamalarda, tekrar deneme sayılarını ve bekleme sürelerini eksponansiyel olarak artırmak daha uygun olabilir.</li><li><strong>Düşük gecikme süreleri ile çok sayıda tekrar deneme yapmak, tam kapasite çalışan ya da buna yakın çalışan bir servisi cevap veremez hale getirebilir. </strong>Böyle bir tekrar deneme politikası, faydalı bir iş yapmak yerine, sürekli olarak hata alan bir işlemi çağırdığı için uygulamanın cevap verme oranını düşürür.</li><li><strong>Bir istek, yeterli sayıdaki denemeden sonra hala hata alıyorsa, aynı kaynağa yapılan istekleri kesip, <em>belirli bir süre direk olarak hata dönmesi</em> daha faydalı olabilir.</strong> Bu süre dolduğu zaman, durumun düzelmediğini kontrol etmek için, bir veya birkaç isteğin hata alan servise erişimine izin verebilir.</li><li><strong>Tekrar deneme politikası uygulayan bir uygulama tarafından çağrılan bir servisteki işlemlerin </strong><a href="https://developer.mozilla.org/en-US/docs/Glossary/Idempotent"><strong>idempotent</strong></a><strong> (bir işlemi ilk defa çağırdığımızdaki etki ile sonraki çağrımlardaki etkisinin aynı olması durumu) olması gerekir.</strong> Örneğin, bir servise yaptığımız istek, servis tarafından alındı ve başarılı bir şekilde işlendi ancak geçici bir hatadan dolayı, bu isteği işlediğine dair yaptığı sonucu çağırana iletemedi. Bu durumda, uygulamadaki tekrar deneme mantığı, isteğin karşı tarafa ulaşmadığını düşünerek isteği tekrar göndermeyi deneyebilir. Örneğin, kullanıcı kayıtlarının, veritabanına ekleme, silme ve güncelleme işlemlerini yapan bir servisimiz olsun, bu servise HTTP PUT (güncelleme) isteği gönderdiğimizde, bu servis işlemi yapıp, kendisini çağıran uygulamaya cevap dönemese bile bu işlemi tekrarladığımızda yine güncelleme yapacağı için sonuç değişmez (idempotent) ancak bu servise HTTP POST (ekleme) isteği gönderdiğimizde, bu servis işlemi yapıp, kendisini çağıran uygulamaya cevap dönemezse, bu servis tekrar çağrıldığında ikinci defa aynı kayıt eklenmiş olacaktır. (non-idempotent)</li><li><strong>Tekrar deneme politikasının, alınan hata tipine göre şekillenmesi gerekir.</strong> Bir servise yapılan istekler çeşitli sebeplerden dolayı hata alabilir. Bazı hataların çok kısa sürede düzelmesi beklenirken bazı hataların uzun süreceği beklenebilir.</li><li><strong>Transactional işlemler yapan servislerde, başarı oranını artırmak ve yapılan işlemi tüm adımlarını geri alma ihtiyacını azaltmak için, tekrar deneme politikalarının çok iyi ayarlanması gerekir.</strong></li><li><strong>Tekrar deneme politikasının, çeşitli hata durumlarına göre tamamen test edildiğinden emin olunmalıdır.</strong> Uygulamanın performansına ve doğruluğuna etkisi olmadığının, servislerde ve kaynaklarda aşırı yüklenmeye sebebiyet vermediğinin, <a href="https://en.wikipedia.org/wiki/Race_condition">race condition</a> veya darboğaz oluşturmadığının kontrol edilmesi gerekir.</li><li><strong>Tekrar deneme mantığı, yalnızca hata veren işlemin tüm süreçleri anlaşıldığında uygulanmalıdır.</strong> Örneğin, tekrar deneme politikası içeren bir görev, başka bir tekrar deneme politikası içeren görevi çağırıyorsa, fazladan eklenen tekrar deneme katmanı uzun gecikmelere sebep olur. Düşük-seviye görevin hızlıca hata alması ve bunun sebebini kendisini çağıran göreve dönmesi daha iyi olabilir. Yüksek-seviye görev kendi politikasına göre bu hatayı nasıl ele alacağına karar verebilir.</li><li><strong>Tekrar denemeye sebep olan tüm hataların loglanması gerekir ki altta yatan problem tespit edilebilsin.</strong></li><li><strong>Hataların, uzun süreli ya da kalıcı olup olmayacaklarını bulmak için servisin ya da kaynağın meydana gelebilecek tüm hatalarının araştırılması gerekir.</strong> Böyle bir durumda, hatayı exception olarak değerlendirmekte fayda var. Uygulama hatayı rapolayıp ya da loglayıp, eğer varsa alternatif bir servisi çalıştırmayı deneyebilir ya da düşük fonksiyonellikte çalışan başka bir servisi önerebilir.</li></ul><h3>Ne Zaman Kullanmalı?</h3><ul><li><strong>Bir uygulama uzaktaki bir servise ya da kaynağa erişirken geçici hatalarla karşılaşılıyorsa kullanılmalıdır</strong>. Bu hatalar, kısa sürmesi ve tekrar denendiğinde başarılı olması beklenilen hatalardır.</li></ul><h3>Ne Zaman Kullanılmamalı?</h3><ul><li><strong>Uzun sürmesi beklenen hatalarda kullanılmamalıdır.</strong> Çünkü uygulama düzelmeyecek bir hata için tekrar deneme yaparak, boştan yere zaman ve kaynak tüketir.</li><li><strong>Uygulama içerisindeki koddan kaynaklı iç hatalar gibi hataları düzeltmek için kullanılmamalıdır.</strong></li><li><strong>Sistemdeki ölçeklendirme sorununa işaret eden hataları düzeltmek için kullanılmamalıdır.</strong> Bir uygulama sürekli olarak “meşgul” hatası alıyorsa, bu genellikle servisin ya da kaynağın ölçeklenmesi gerektiği anlamına geliyordur.</li></ul><h3>Örnek</h3><p>Bu örnek, Retry kalıbını nasıl gerçekleştirebileceğimizi gösteriyor. <strong>OperationWithBasicRetryAsync</strong> metodu, aşağıda belirtildiği gibi, <strong>TransientOperationAsync</strong> metodu yardımıyla (bu metodun detayları çağrılan servise özel olarak doldurulacak ve bu yüzden örnek kodda belirtilmemiştir) asenkron bir şekilde dış servisi çağırıyor.</p><pre>private int retryCount = 3;<br>...<br><br>public async Task OperationWithBasicRetryAsync()<br>{<br>  int currentRetry = 0;  <br>  for (; ;)  <br>  {    <br>    try    <br>    {      <br>      // Dış servis çağrılır.      <br>      await TransientOperationAsync();                          <br>      <br>      // Return ya da break.      <br>      break;    <br>    }    <br>    catch (Exception ex)    <br>    {      <br>      Trace.TraceError(&quot;Operation Exception&quot;);      <br>      currentRetry++;      <br>      <br>      // Hatanın geçici (transient) olup olmadığı ve<br>      // tekrar deneme sayısını aşıp aşmadığına göre     <br>      if (currentRetry &gt; this.retryCount || !IsTransient(ex))      <br>        {        <br>          // hata geçici değilse exception fırlatılır.<br>          throw;      <br>        }    <br>    }<br>      <br>    // İşlemi tekrar denemek için bekle.<br>    Await.Task.Delay();  <br>  }<br>}<br>// Dış servise yapılan isteği içeren metod (detaylar gösterilmiyor).<br>private async Task TransientOperationAsync(){...}</pre><p>Bu metodu çağıran kısım <strong>for</strong> döngüsü içerisinde <strong>try/catch</strong> bloğunda bulunmaktadır. <strong>TransientOperationAsync</strong> metodu başarılı olmuşsa exception fırlatmadan <strong>for</strong> döngüsünden çıkar. Başarılı olamamışsa, bu hatanın geçici olup olmadığına karar verilir, eğer geçici ise tekrar deneme maksimum sayısını aşıp aşmadığı kontrol edilir ve hata fırlatılır, geçici değilse direk olarak hata fırlatılır.</p><p><strong>IsTransient</strong> (hata geçici mi) metodu, aşağıdaki gibi, kodun çalıştığı ortamla ilgili belirli exception’ları kontrol eder. Bu metodun içeriği, çalışan işlemin eriştiği kaynaklara ve ortama göre değişiklik gösterebilir.</p><pre>private bool IsTransient(Exception ex)<br>{<br>  // Hata geçicimi kararı verilir.<br>  // Bazı durumlarda basitce exception tipini kontrol etmek yeterlidir,<br>  // bazen de exception&#39;ın diğer özelliklerini incelemek gerekebilir.<br>  if (ex is OperationTransientException)<br>    return true;<br><br>  var webException = ex as WebException;<br>  if (webException != null)<br>    {<br>      // Eğer web exception ise ve aşağıdaki durumları içeriyorsa<br>      // geçici olabilir.<br>      return new[]<br>        {<br>          WebExceptionStatus.ConnectionClosed,<br>          WebExceptionStatus.Timeout,<br>          WebExceptionStatus.RequestCanceled<br>        }.<br>        Contains(webException.Status);<br>    }<br>    <br>    // Exception kontrolleri buradan devam ediyor.<br>  return false;<br>}</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5b2db303a7a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unit Test, Test Edilebilir Kod Nasıl Yazılır, ve Neden Önemlidir]]></title>
            <link>https://medium.com/@mugrcn/unit-test-test-edilebilir-kod-nas%C4%B1l-yaz%C4%B1l%C4%B1r-ve-neden-%C3%B6nemlidir-dcd419c16a26?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/dcd419c16a26</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[testable-code]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Thu, 26 Jan 2023 00:18:59 GMT</pubDate>
            <atom:updated>2023-01-26T08:32:19.963Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu makalede, unit test yazmanın kolay olduğunu; unit test yazmayı zorlaştıran gerçek problemlerin, aslında kötü tasarlanmış, test edilemeyen kodlardan kaynaklandığını göreceğiz. Nelerin kodu test etmeyi zorlaştırdığını, test edilebilirliği arttırmak için hangi anti-pattern’ler ve kötü yöntemlerden kaçınmamız gerektiğini, ve test edilebilir kod yazarak başka hangi faydaları elde edeceğimizi göreceğiz. Test edilebilir kod yazmak yalnızca yazacağımız testi kolaylaştırmayacak, aynı zamanda yazdığımız kodu daha sağlam yapacak ve bakımını kolaylaştıracak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7oOJR0l15fdY2Vtk.png" /></figure><p>Unit testler iyi bir yazılımcının en temel aracıdır. Ancak bazen iyi bir unit test yazmak zor olabilir. Kendisinin ya da başkasının kodu için unit test yazarken zorlanan yazılımcılar, kendilerinin temel test bilgilerinden ve tekniklerinden yoksun olduklarını düşünürler.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*ocAk8DsfBZIWPlyT821rKA.gif" /></figure><h3>Unit Test Nedir?</h3><p>En basit haliyle unit test, uygulamamızın küçük bir bölümünün davranışını <strong>diğer parçalardan bağımsız olarak</strong> doğrulama metodudur. Tipik bir unit test 3 fazdan oluşur: İlk olarak, test edilmek istenilen kodu çalıştırmak için gereken parçalar hazır hale getirilir, sonra test edilmek istenilen asıl parça tetiklenir (genelde metod çağrımı yapılır) ve son olarak sonuç davranışı gözlemlenir. Eğer sonuç davranışı beklentilerimizi karşılıyorsa unit test geçer aksi halde test edilen kodun bir yerlerinde hata olduğu anlamına gelir. Bu fazlar, Arrange, Act ve Assert olarak bilinir kısaca AAA.</p><p>Unit testler iki kategoriye ayrılır: <em>state-based</em> (durum bazlı) ve <em>interaction-based </em>(etkileşim bazlı). Test edilen sistemin doğru sonuçlar ürettiğini veya doğru durumlara evrildiğini doğrulamaya <strong>state-based </strong>unit test, belirli methodları çağırıp çağırmadığını doğrulamaya <strong>interaction-based</strong> unit test denir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*6jcqYZYgi5fLZ7poXh7cIA.png" /></figure><blockquote><em>Ben burada C# kullancağım ancak belirtilen konseptler tüm nesne-tabanlı dillere uyarlanabilir.</em></blockquote><p>Basit bir unit test şu şekilde görünür: (<strong>Palindrom</strong>, tersten okunuşu da aynı olan cümle, sözcük ve sayılara denilmektedir.)</p><pre>[TestMethod]<br>public void IsPalindrome_ForPalindromeString_ReturnsTrue()<br>{<br>    // Arrange (hazırlık) fazında, test edilecek parçanın bulunduğu nesneyi oluşturuyoruz.<br>    // Test edilecek şey bir metod, tek bir nesne ya da birbirine bağlı nesnelerden oluşabilir.<br>    // Static bir metodu test ediyorsak Arrange fazı boş olabilir.<br>    PalindromeDetector detector = new PalindromeDetector();<br>    <br>    // Act (tetikleme) fazında, test edilecek parçayı tetikleriz ki bu genelde bir metod olur.<br>    // Eğer bu metod bize birşey dönerse bu sonuçları toplarız.<br>    // Veya, Eğer bu metod birşey dönmezse istediğimiz değişikliklerin yapılıp yapılmadığını kontrol ederiz.<br>    bool isPalindrome = detector.IsPalindrome(&quot;kayak&quot;);<br>    // Assert (teyit etme) fazında unit testin, beklediğimiz sonuçları üretip üretmediğini kontrol ederiz.<br>    Assert.IsTrue(isPalindrome);<br>}</pre><h3>Unit Test vs. Entegrasyon Testi</h3><p>Bir diğer önemli konu da unit test ile entegrasyon testi arasındaki farklardır.</p><p><strong>Unit testler</strong>, y<em>azılımın küçük bir parçasının, diğer parçalardan bağımsız olarak, davranışını doğrulamaktır.</em> Unit test’ler dar bir kapsamda her bir parçanın doğru çalışıp çalışmadığından emin olmamızı sağlar.</p><p>Diğer yandan <strong>entegrasyon testleri</strong>, <em>farklı parçaların, birbirleriyle, gerçek ortamda düzgün çalışıp çalışmadığını belirlerler.</em> Genellikle, veritabanları, web sunucuları gibi dış kaynaklara ihtiyaç duyarlar.</p><p>Bu yüzden nasıl bir test yapmak istediğinize karar vermelisiniz: unit test mi entegrasyon testi mi? Aradaki fark bazen kafa karıştırıcı olabilir. Yazdığımız unit testin çalışabilmesi için web servislerin veya veritabanlarının kurulu olmasına ihtiyaç duyuyorsak bir şeyler yanlış demektir. Fındık kırmak için balyoz kullanmaya benzer. Bunun anlamı kötü tasarımdır.</p><p>Tekrar söylemek gerekirse unit test’ler dış kaynaklara erişmemelidir.</p><blockquote>Unit test yazmanın gizli bir tarifi yoktur. Ancak test edilebilir kod yazmanın bazı teknikleri vardır.</blockquote><h3>Test Edilebilen ve Edilemeyen Kod</h3><p>Bazı kodlar için unit test yazmak zor hatta bazen imkansızdır. Bir kodun test edilmesini zorlaştıran nedir? Şimdi test edilebilir kod yazarken kaçınmanız gereken, bazı anti-pattern’ler, code smells (kötü kokan kod) ve kötü yöntemleri inceleyelim.</p><h3>Aynı Girdi İle Farklı Sonuçlar Veren Parçalarla Kodu Zehirlemek</h3><p>Basit bir örnek ile başlayalım. Bir akıllı ev cihazı yapıyoruz ve amacımız “akşam veya gece bir hareket tespit etmişsek, bahçenin ışığını otomatik olarak açmak” olsun. Bize, günün hangi zamanında olduğumuzu string olarak dönen bir metod yazalım. (“Gece”, “Sabah”, “Öğlen” veya “Akşam”):</p><pre>public static string GetTimeOfDay()<br>{<br>    DateTime time = DateTime.Now;<br>    if (time.Hour &gt;= 0 &amp;&amp; time.Hour &lt; 6)<br>    {<br>        return &quot;Gece&quot;;<br>    }<br>    if (time.Hour &gt;= 6 &amp;&amp; time.Hour &lt; 12)<br>    {<br>        return &quot;Sabah&quot;;<br>    }<br>    if (time.Hour &gt;= 12 &amp;&amp; time.Hour &lt; 18)<br>    {<br>        return &quot;Öğlen&quot;;<br>    }<br>    return &quot;Akşam&quot;;<br>}</pre><p>Temel olarak, bu metod şu anki sistem zamanını alır ve o değere göre günün hangi zamanında olduğumuz sonucunu döner. Eee, ne var bu kodda?</p><p>Unit test yazma açısından bakarsak, bu metod için doğru bir şekilde <em>state-based (durum-bazlı) </em>unit test yazamayacağımızı görürüz. <strong>DateTime.Now</strong> , programı veya testi çalıştırdığımız zamana göre değişen gizli bir input’tur. Bu yüzden, bu metod farklı zamanlarda çalıştırıldığında farklı sonuçlar üretir.</p><p>Gerçek sistem saatini değiştirmeden, sonucu tahmin edilemeyen (<strong>non-deterministic)</strong> sonuçlar üreten GetTimeOfDay() metodunu test etmek imkansız hale gelir. Şimdi de ihtiyacımız olan test metodunu yazalım:</p><pre>[TestMethod]<br>public void GetTimeOfDay_At6AM_ReturnsMorning()<br>{<br>    try<br>    {<br>        // Setup: sistem saatini sabah 6 yapalım<br>        ...<br>        // Arrange fazı boş: static metodları test ederken hazırlık yapmamıza gerek yok.<br>        // Act<br>        string timeOfDay = GetTimeOfDay();<br>        // Assert<br>        Assert.AreEqual(&quot;Sabah&quot;, timeOfDay);<br>    }<br>    finally<br>    {<br>        // Teardown: sistem zamanını geri al<br>        ...<br>    }<br>}</pre><p>Bu tarz testler, bir önceki <a href="https://medium.com/@mugrcn/unit-testing-nedir-neden-%C3%B6nemlidir-ve-i%CC%87yi-bir-testin-%C3%B6zellikleri-nelerdir-b45982d63d6e">yazımızda</a> bahsettiğimiz kuralları ihlal eder. Bu şekilde test yazmak maliyetlidir (maliyetli setup (kurulum) ve teardown (yıkım) mantığı yüzünden), güvenilmezdir (test ettiğimiz sistemde hata olmasa bile örneğin yetkiniz yoksa sistem saatini değiştiremezsiniz), ve aynı zamanda hızlı çalışmasının garantisi yoktur. Ve son olarak, bu gerçek bir unit test değildir — unit test ile entegrasyon testi arasında birşeydir, çünkü basit bir metodu test edebilmek için dış kaynak (burada sistem saati) bağımlılıklarını istediği şekilde değiştirmeye çalışıyor. Attığımız taş ürküttüğümüz kurbağaya değmiyor.</p><p>Bütün bu test edilebilme problemlerinin sebebi, kötü yazılmış GetTimeOfDay() API’ sinden kaynaklanıyor. Bu haliyle birçok sorunu bulunmaktadır:</p><ul><li><strong>Belirli veri kaynağına aşırı bağımlı.</strong> Metod yalnızca çalıştığı makinanın sistem saati ile çalışabilir. Farklı kaynaklardan edindiğimiz saat bilgisiyle, bu metodu farklı yerlerde tekrar kullanamayız. Bu şekilde sıkı sıkıya bağımlılık (tight coupling) birçok test edilebilme probleminin ana kaynağıdır.</li><li><a href="https://en.wikipedia.org/wiki/Single_responsibility_principle"><strong>Single Responsibility Principle</strong></a><strong> (SRP)‘i ihlal ediyor.</strong> Bu metodun birden fazla sorumluluğu bulunuyor; veriyi çekiyor aynı zamanda onu işliyor. SRP ihlalinin diğer bir belirtisi ise, GetTimeOfDay() metodu ya içeride çalışan mantığın değişmesi sebebiyle değişebilir ya da saat kaynağı değiştirilmek istenildiğinde değişebileceği için <em>yalnızca tek bir sebepten dolayı değişebilir</em> kuralını ihlal eder.</li><li><strong>İşini yapmak için hangi bilgilere ihtiyaç duyduğu belli değil.</strong> Yazılımcılar, hangi gizli girdilerin kullanıldığı ve nereden geldiğini bulmak için tüm satırları okumak zorundalar. Metod tanımı, metodun davranışını çözmek için tek başına yeterli değil.</li><li><strong>Tahmin etmesi ve bakımı zor.</strong> Dışarıdan (kod dışından) değiştirilebilecek durumlara bağımlı olarak davranışı değişebilecek kaynak kodu okuyarak tahmin edilemez.</li></ul><p>API’yi inceledikten sonra, sıra geldi düzeltmeye! Neyse ki bunları düzeltmek, kusurlarını konuşmaktan daha kolay — sadece sıkı bağımlılıkları ortadan kaldırmamız yeterli.</p><h4>API’yi Düzeltmek: Metod Argümanı Eklemek</h4><p>API’yi düzeltmenin en bariz ve kolay yolu metoda argüman eklemek:</p><pre>public static string GetTimeOfDay(DateTime dateTime)<br>{    <br>    if (dateTime.Hour &gt;= 0 &amp;&amp; dateTime.Hour &lt; 6)<br>    {<br>        return &quot;Gece&quot;;<br>    }<br>    if (dateTime.Hour &gt;= 6 &amp;&amp; dateTime.Hour &lt; 12)<br>    {<br>        return &quot;Sabah&quot;;<br>    }<br>    if (dateTime.Hour &gt;= 12 &amp;&amp; dateTime.Hour &lt; 18)<br>    {<br>        return &quot;Öğlen&quot;;<br>    }<br>    return &quot;Akşam&quot;;<br>}</pre><p>Metod, DateTime argümanına ulaşmak için gizlice bu bilgiyi aramak yerine kendisini çağırandan bu bilgiyi temin ediyor. Unit test açısından bu metod artık tahmin edilebilir olduğu için düzeldi. (sonuç artık verdiğimiz girdiye bağlı):</p><pre>[TestMethod]<br>public void GetTimeOfDay_For6AM_ReturnsMorning()<br>{<br>    // Arrange fazı boş: static metodu test ediyoruz<br>    // Act<br>    string timeOfDay = GetTimeOfDay(new DateTime(2022, 12, 31, 06, 00, 00));<br>    // Assert<br>    Assert.AreEqual(&quot;Sabah&quot;, timeOfDay);<br>}</pre><p>Basit bir düzenleme biraz önce bahsettiğimiz tüm sorunları çözdü. Bu metod artık test edilebilir, peki istemciler (<em>clients)</em>? Zaman girdisi artık çağıran tarafların sorumluluğunda olduğundan şimdi de onlar test edilemez duruma geldiler. Şimdi de bu durumu nasıl çözeceğimizi ele alalım.</p><h4>İstemcinin Sorununu Giderme: DEPENDENCY INJECTION</h4><p>Akıllı ev sisteminin kodlarını yazmaya devam edelim. Biraz önce bahsettiğimiz şekilde GetTimeOfDay(DateTime dateTime) metodundan aldığı günün zamanına göre ışıkları açıp kapatan akıllı ev kontrolünün kodunu yazalım:</p><pre>public class SmartHomeController<br>{<br>    public DateTime LastMotionTime { get; private set; }<br><br>    public void ActuateLights(bool motionDetected)<br>    {<br>        DateTime time = DateTime.Now; // !!!<br>        // Son yakalanan hareketin zamanını al<br>        if (motionDetected)<br>        {<br>            LastMotionTime = time;<br>        }<br>        <br>        // Eğer hareket yakalandığında akşam veya geceyse, ışıkları aç.<br>        string timeOfDay = GetTimeOfDay(time);<br>        if (motionDetected &amp;&amp; (timeOfDay == &quot;Akşam&quot; || timeOfDay == &quot;Gece&quot;))<br>        {<br>            BackyardLightSwitcher.Instance.TurnOn();<br>        }<br>        // Bir dakika boyunca hareket tespit edilmemişse ya da gündüz ise, ışıkları kapat.<br>        else if (time.Subtract(LastMotionTime) &gt; TimeSpan.FromMinutes(1) || (timeOfDay == &quot;Sabah&quot; || timeOfDay == &quot;Öğlen&quot;))<br>        {<br>            BackyardLightSwitcher.Instance.TurnOff();<br>        }<br>    }<br>}</pre><p>Burada da yine aynı şekilde gizli DateTime.Now input problemi oluştu. Aradaki tek fark, problemin bir üst sınıfa çıkmış olmasıdır. Bu problemi de DateTimedeğerinin, methodu çağıran tarafdan verilmesi istenerek, yani metod imzasını ActuateLights(bool motionDetected, DateTime dateTime) olarak değiştirerek çözebiliriz. Ancak problemi yine bir üst seviyeye taşımış olacağız. Bunun yerine hem ActuateLights(bool motionDetected) metodunun hem de istemcilerin test edilebilir olması için başka bir teknik uygulayalım: <a href="https://en.wikipedia.org/wiki/Inversion_of_control">Inversion of Control</a>, diğer bir deyimle IoC.</p><p>Inversion of Control (Bağımlılıkların tersine çevrilmesi) basit ama aynı zamanda gevşek bağlı (loosely coupled) kodlar oluşturmak için etkili bir yöntemdir. (Kodları ne kadar birbiriyle gevşek bağlı hale getirirsek, her birini birbirinden bağımsız olarak analiz edebilme şansımız artar.) IoC’nin kilit noktası, karar veren kodu (bir işi <em>hangi durumda</em> yapacak), işi yapan koddan (hangi durum olduğunda <em>ne</em> yapacak) ayırmasıdır. Bu teknik esnekliği artırır, kodu modüler yapar, ve parçalar arasındaki bağlılıkları azaltır.</p><p>Inversion of Control farklı yollarla gerçekleştirilebilir; hemen bir örnek üzerinden inceleyelim — Constructor üzerinden Dependency Injection — ve SmartHomeController API’sinin test edilebilir olmasını nasıl sağlayacağını görelim.</p><p>İlk olarak, saati elde etmemizi sağlayacak olan metod imzasına sahip IDateTimeProvider interface’ini oluşturalım:</p><pre>public interface IDateTimeProvider<br>{<br>    DateTime GetDateTime();<br>}</pre><p>Sonra, SmartHomeController API’sini, IDateTimeProvider implementasyonunu constructor yoluyla referans alacak şekilde değiştirelim, ve zaman bilgisi edinme işinin bu nesne tarafından yapılmasını sağlayalım:</p><pre>public class SmartHomeController<br>{<br>    private readonly IDateTimeProvider _dateTimeProvider; // Bağımlılık<br>    <br>    public SmartHomeController(IDateTimeProvider dateTimeProvider)<br>    {<br>        // İhtiyaç duyulan bağımlılığı contructor&#39;da inject edelim<br>        _dateTimeProvider = dateTimeProvider;<br>    }<br>    public void ActuateLights(bool motionDetected)<br>    {<br>        DateTime time = _dateTimeProvider.GetDateTime(); // Zaman bilgisi edinme işini devretmek<br>        // Geri kalan ışık kontrol mantığı buradan devam ediyor...<br>    }<br>}</pre><p>Şimdi bu işleme neden Inversion of Control (Bağımlıklıkların tersine çevrilmesi) dendiğini görebiliyoruz. Zaman bilgisi edinmek için hangi mekanizmaların kullanılması <em>kontrol </em>ünü tersine çevirdik (<em>inverted</em>), ve şimdi bu iş, SmartHomeController ‘ı kullanan istemcinin sorumluluğundadır, SmartHomeController ‘ın kendisinde değildir. Bu sayede ActuateLights(bool motionDetected) metodunun çalıştırılması dışarıdan yönetilen iki şeye bağlıdır: motionDetected parametresi ve SmartHomeController contructor’ında verilen IDateTimeProvider implementasyonuna.</p><p>Peki bu unit test yapmak için neden önemlidir? Bu düzenlemeyle, hem çalışan kodda hem de unit test kodunda, farklı IDateTimeProvider implementasyonları kullanabiliyoruz. Normal çalışma ortamlarında gerçek implementasyonları kullanırız (örnek olarak gerçek sistem zamanını okuyan). Unit test ortamında, test ettiğimiz senaryonun gerçekleşmesini sağlayacak şekilde istediğimiz DateTime değerini veren “fake” implementasyonunu kullanırız.</p><p>IDateTimeProvider ‘ın fake implementasyonu şu şekildedir:</p><pre>public class FakeDateTimeProvider : IDateTimeProvider<br>{<br>    public DateTime ReturnValue { get; set; }<br><br>    public DateTime GetDateTime() { return ReturnValue; }<br>    public FakeDateTimeProvider(DateTime returnValue) { ReturnValue = returnValue; }<br>}</pre><p>Bu sınıf yardımıyla, SmartHomeController ‘ı aynı girdi ile farklı sonuçlar veren faktörlerden izole ederek, durum-bazlı unit testimizi gerçekleyebiliriz. Şimdi, hareket algılandığında, hareketin algılandığı zamanın LastMotionTime değişkeninde saklandığını doğrulayalım:</p><pre>[TestMethod]<br>void ActuateLights_MotionDetected_SavesTimeOfMotion()<br>{<br>    // Arrange<br>    var controller = new SmartHomeController(new FakeDateTimeProvider(new DateTime(2022, 12, 31, 23, 59, 59)));<br>    // Act<br>    controller.ActuateLights(true);<br>    // Assert<br>    Assert.AreEqual(new DateTime(2022, 12, 31, 23, 59, 59), controller.LastMotionTime);<br>}</pre><p>Harika! Kodu refactor yapmadan böyle bir test yazamazdık. Şimdi aynı girdi ile farklı sonuçlar veren faktörleri ortadan kaldırdığımıza ve durum-bazlı senaryomuzu doğruladığımıza göre, sizce artık SmartHomeController tamamen test edilebilir hale geldi mi?</p><h3>Yan Etkilerle Kodu Zehirlemek</h3><p>Aynı girdi ile farklı sonuçlar veren durumu düzeltmemize ve bu durumu test edebilmiş olmamıza rağmen kod hala test edilebilir değil!</p><p>Şimdi de ActuateLights(bool motionDetected) metodunun ışıkları açmak ve kapatmaktan sorumlu olan aşağıdaki bölümünü inceleyelim:</p><pre>// Eğer akşam veya gece hareket algılandıysa ışıkları yak.<br>if (motionDetected &amp;&amp; (timeOfDay == &quot;Akşam&quot; || timeOfDay == &quot;Gece&quot;))<br>{<br>    BackyardLightSwitcher.Instance.TurnOn();<br>}<br>// Eğer bir dakika boyunca hareket algılanmamışsa veya sabah veya öğlen ise ışıkları kapat.<br>else if (time.Subtract(LastMotionTime) &gt; TimeSpan.FromMinutes(1) || (timeOfDay == &quot;Sabah&quot; || timeOfDay == &quot;Öğlen&quot;))<br>{<br>    BackyardLightSwitcher.Instance.TurnOff();<br>}</pre><p>Görüldüğü üzere, SmartHomeController ışık açma ve kapatma işlemininin sorumluluğunu <a href="https://en.wikipedia.org/wiki/Singleton_pattern">Singleton pattern</a> kullanan BackyardLightSwitcher nesnesinden bekliyor. Bu tasarımdaki sorun ne?</p><p>ActuateLights(bool motionDetected) metoduna tam olarak unit test yazdık diyebilmemiz için durum-bazlı testin yanısıra etkileşim-bazlı test de yapmamız gerekiyor; yani gerekli koşullar sağlandığında ışık kapatma ve açma methodlarının çağrıldığından emin olmamız gerekiyor. Malesef şu anki tasarım ile BackyardLightSwitcher nesnesinin TurnOn() ve TurnOff() metodları sistemde durum değişikliklerine sebep oluyor, başka bir deyişle <a href="https://en.wikipedia.org/wiki/Side_effect_(computer_science)">yan etkiler</a> üretiyor. Bu metodların çağrıldığını doğrulamanın tek yolu, ilgili yan etkilerin gerçekleşip gerçekleşmediğini kontrol etmektir ki bu çok meşakatlidir.</p><p>Diyelim ki hareket sensörü, bahçe lambası, ve akıllı kontrol cihazı birbirlerine kablosuz ağ ile bağlılar. Bu durumda, unit test network trafiğini algılayıp analiz edebilir. Ya da bu cihazlar birbirleri ile kablo üzerinden bağlanmışlarsa elektrik devresine uygulanan voltajın doğruluğunu kontrol edebilir. Ya da, bir ışık sensörü yardımıyla, ışık gerçekten açık mı kapalı onu kontrol edebilir.</p><p>Görüldüğü üzere, yan-etkileri olan bir metod için unit test yazmak, aynı girdi ile farklı sonuçlar üretenler kadar zordur, hatta bazen imkansızdır. Bunlar için unit test yazmaya kalktığımızda şimdiye kadar gördüğümüz problemlerle karşılaşırız.</p><p>Bu tarz test problemlerinin sebebi yine kötü yazılmış API kaynaklıdır, yazılımcının test yazabilme kabiliyeti değildir. Her ne kadar ışık kontrolü çok iyi yapılmış olsa da, SmartHomeController API’si zaten aşina olduğumuz sorunlarla uğraşır:</p><ul><li><strong>İmplementasyon ile sıkı sıkıya bağımlıdır</strong>. API BackyardLightSwitcher nesnesine birebir bağlıdır. ActuateLights(bool motionDetected) metodunu bahçedeki ışıktan başka ışığı yakmak için kullanamayız.</li><li><strong>Single Responsibility Prensibini çiğnemektedir.</strong> API iki sebepten dolayı değişebilir: İlk olarak, içeride kullanılan mantık (ışığı akşam açmayıp yalnızca gece açmak isteyebiliriz) ve ikinci olarak, ışık açma kapama mekanizmasını bir başkasıyla değiştirmek isteyebiliriz.</li><li><strong>Bağımlılıkları bulunuyor.</strong> Yazılımcının SmartHomeController API’sinin BackyardLightSwitcher bileşenine bağımlı olduğunu kaynak kodu okumadan bilme imkanı yok.</li><li><strong>Anlamak ve bakım yapmak zor.</strong> Ya tüm şartlar uygun olduğunda ışık yanmazsa? Bize hiçbir faydası olmayacağı halde, BackyardLightSwitcher’daki hatadan kaynaklı bug yüzünden, SmartHomeController sınıfında olduğunu düşündüğümüz sorunu çözmek için zaman harcayacağız. (Hatta daha acısı sorun patlamış ampülden kaynaklı bile olabilir!).</li></ul><p>Hem test edilebilirlik hem de düşük kalite API sorununun çözümü, yine, birbirine sıkı sıkıya bağlı bileşenleri ayırmak olacaktır. Bir önceki örnekteki gibi Dependency Injection bu sorunu çözebilirdi; sadece SmartHomeController içerisine ILightSwitcherekleyerek, ışık açma kapatma sorumluluğunu ona devrederek, ve test amaçlı fake ILightSwitcher implementasyonu oluşturup doğru şartlarda uygun metodların çağrılıp çağrılmadığına bakabiliriz. Ancak yine Dependency Injection kullanmak yerine, sorumlulukları bölmek için alternatif bir yaklaşımı inceleyelim.</p><h4>API’I ONARMAK: ÜST DÜZEY FONKSİYONLAR (HIGHER-ORDER FUNCTIONS)</h4><p>Bu yöntem, birinci-sınıf fonksiyon (<a href="https://en.wikipedia.org/wiki/First-class_function"><em>first-class functions</em></a>) özelliğini destekleyen tüm object-oriented dillerde yapabileceğimiz bir seçenek. C#’ın fonksiyonel özelliklerinin avantajını kullanalım ve ActuateLights(bool motionDetected) metoduna iki tane daha parametre ekleyelim: ışığı açmak ve kapatmakla görevli bir çift Action delegate. Bu çözüm ile, metod üst-düzey fonksiyona (<a href="https://en.wikipedia.org/wiki/Higher-order_function"><em>higher-order function</em></a>) dönüşecektir:</p><pre>public void ActuateLights(bool motionDetected, Action turnOn, Action turnOff)<br>{<br>    DateTime time = _dateTimeProvider.GetDateTime();<br>    <br>    // Son gerçekleşen hareketin zamanını güncelle.<br>    if (motionDetected)<br>    {<br>        LastMotionTime = time;<br>    }<br>    <br>    // Eğer akşam veya gece hareket algılanmışsa ışığı aç.<br>    string timeOfDay = GetTimeOfDay(time);<br>    if (motionDetected &amp;&amp; (timeOfDay == &quot;Akşam&quot; || timeOfDay == &quot;Gece&quot;))<br>    {<br>        turnOn(); // İlgili delegate&#39;i tetiklemek: sıkı bağımlılık ortadan kalktı.<br>    }<br>    // Bir dakika boyunca hareket algılanmamışsa, ya da sabah veya öğlen ise ışığı kapat.<br>    else if (time.Subtract(LastMotionTime) &gt; TimeSpan.FromMinutes(1) || (timeOfDay == &quot;Sabah&quot; || timeOfDay == &quot;Öğlen&quot;))<br>    {<br>        turnOff(); // İlgili delegate&#39;i tetiklemek: sıkı bağımlılık ortadan kalktı.<br>    }<br>}</pre><p>Bu daha önce gördüğümüz object-oriented Dependency Injection yaklaşımından daha çok fonksiyonel yönelimli bir çözüm; ancak Dependency Injection yaklaşımına göre daha az kodla daha ucuz bir şekilde aynı sonucu yakalamamızı sağlıyor. Artık SmartHomeController nesnesinin ihtiyaç duyduğu fonksiyonelliği sağlamak için gerekli olan interface’den türetilip implemente edilmiş bir sınıfa ihtiyacımız kalmadı, sadece fonksiyon tanımını parametre olarak iletmemiz yeterli. Higher-order fonksiyonlar Inversion of Control implementasyonunun başka bir yolu gibi düşünebiliriz.</p><p>Şimdi, etkileşim-bazlı unit test çalıştırmak için, kolayca fake aksiyonları parametre olarak geçebiliriz:</p><pre>[TestMethod]<br>public void ActuateLights_MotionDetectedAtNight_TurnsOnTheLight()<br>{<br>    // Arrange: gerçek ışık açma kapatma işlemleri yapmak yerine boolean değerleri değiştiren bir çift aksiyon tanımlarız.<br>    bool turnedOn  = false;<br>    Action turnOn  = () =&gt; turnedOn = true;<br>    Action turnOff = () =&gt; turnedOn = false;<br>    var controller = new SmartHomeController(new FakeDateTimeProvider(new DateTime(2022, 12, 31, 23, 59, 59)));<br>    // Act<br>    controller.ActuateLights(true, turnOn, turnOff);<br>    // Assert<br>    Assert.IsTrue(turnedOn);<br>}</pre><p>Sonunda, SmartHomeController API’ı tamamen test edilebilir oldu ve artık hem durum-bazlı hem de etkileşim-bazlı testleri gerçekleştirebiliriz. Yine, dikkat edersek test edilebilirliği artırmanın yanında karar-veren ve aksiyon alan kodu ayırmak bağımlılık problemini çözmemize, daha temiz ve tekrar kullanılabilir API yapmamızı sağladı.</p><p>Şimdi, tam unit test kapsamını gerçeklemek için, tüm olasılıkları doğrulayan testler yazabiliriz. Artık unit test yazmak çok kolaylaştı.</p><h3>Kirlilik ve Test Edilebilirlik</h3><p>Yan etkiler ve aynı girdi ile farklı sonuç veren durumlar kodda benzer yıkıcı etkilere sahip. Dikkatsizce kullanıldığında, yanıltıcı, anlaması ve bakımı zor, sıkı bağlı, tekrar kullanılamaz, ve test edilemez kodlara sebep olurlar.</p><p>Diğer yandan, beklediğimiz sonuçları üreten, yan etkisi olmayan metodları test etmek çok kolaydır ve büyük programlar yazarken tekrar kullanılabilirler. Fonksiyonel programlama açısından bu metodlara <em>saf fonksiyonlar (</em><a href="https://en.wikipedia.org/wiki/Pure_function"><em>pure functions</em></a><em>) </em>denilir. Saf fonksiyonlar için unit test yazarken nadiren sorunla karşılaşırız; tek yapmamız gereken parametreleri ve sonuçları doğrulamaktır. Kodu test edilemez yapan şey, esnek olmayan yapıdaki, değiştirilemeyen kodlardır.</p><p>Kirlilik kodu zehirler: eğer Foo() metodu aynı girdi ile farklı sonuçlar veren ya da yan etkileri olan Bar()metoduna bağımlı ise, o zamanFoo() metodu da aynı duruma düşer. Sonuç olarak tüm kod zehirlenmiş olur. Bu problemleri, uygulamanın boyutuyla çarptığımız zaman, kendimizi bakımı zor olan, gizli bağımlılıkları olan, okuması zor kötü kodlarla baş başa buluruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*m5rDmTzskr6EUXj8SV1jUQ.png" /></figure><h3>Kodu Test Etmenin Zor Olduğunu Belirten Genel Uyarı İşaretleri</h3><p>Test yazarken sorun mu yaşıyorsunuz? Sorun testinizde değil kodunuzdadır.</p><p>Son olarak, kodumuzu test etmenin zor olduğunu gösteren genel uyarı işaretlerini inceleyelim.</p><h3>Static Propery’ler ve Field’lar</h3><p>Static property’ler ve field’lar, diğer bir deyişle global erişilebilen değişkenler, işi tamamlamak için gerekli olan bilgiyi gizleyerek, tahmin edilemeyen sonuçlar üretebilecek pozisyonlar oluşturarak, kodun anlaşılabilirliğini azaltırlar. Değişime açık global değişkenleri okuyan veya güncelleyen fonksiyonlar, tabiatı gereği kirlidir.</p><p>Örneğin, global erişilebilen bir değişkene dayalı sonuç üreten kodun çıktısını bilmek zordur:</p><pre>if (!SmartHomeSettings.CostSavingEnabled) { _swimmingPoolController.HeatWater(); }</pre><p>Ya HeatWater() metodu, çağrılacağından emin olduğumuz halde çağrılmazsa? Çünkü CostSavingEnabled değeri uygulamanın herhangi bir yerinde değiştirilmiş olabilir. Bu durumda sorunu tespit etmek için, bu değişkeni değiştirebilme durumu olan tüm parçaları analiz etmemiz gerekir.</p><p>Diğer yandan, constant değerler, global olarak kullanılabildikleri halde, değiştirilemez oldukları için kullanmakta bir sakınca yoktur:</p><pre>double Circumference(double radius) { return 2 * Math.PI * radius; } // Hala saf bir fonksiyon!</pre><h3>Singleton</h3><p>Esasen, Singleton deseni, global değişken sorununun bir başka versiyonudur. Singleton nesneler, gerçek bağımlılıklarını gizleyerek ve bileşenler arasında gereksiz sıkı bağımlılıklar oluşturarak yanıltıcı API’ları teşvik eder. Aynı zamanda Single Responsibility Presibini çiğnerler, çünkü asli görevlerinin yanı sıra kendi yaşam dönülerini kontrol etmek zorundadırlar.</p><p>Singleton nesneler, unit testleri, sıra-bağımsız tetiklenme özgürlüğünden kolayca çıkarırlar çünkü uygulama ya da unit test çalışması sırasında yaşamları sona ermediğinden, tüm çalışma sırasında durumdan duruma geçebilirler. Aşağıdaki örneği inceleyelim:</p><pre>User GetUser(int userId)<br>{<br>    User user;<br>    if (UserCache.Instance.ContainsKey(userId))<br>    {<br>        user = UserCache.Instance[userId];<br>    }<br>    else<br>    {<br>        user = _userService.LoadUser(userId);<br>        UserCache.Instance[userId] = user;<br>    }<br>    return user;<br>}</pre><p>Yukarıdaki örnekte, ilk çalışan test cache’e ekleme yaparsa, sonraki çalışan test cache olmadığını farzeden bir test ise senaryo hata üretir. Bu durumu çözmek için, UserCache‘i temizleyen (teardown) ekstra kod yazmamız gerekir.</p><p>Singleton kullanmak, çoğu durumda kaçınılması gereken kötü bir yöntemdir; ancak, tasarım deseni olarak Singleton ile single instance nesneleri birbirinden ayırt etmek gerekir. İkinci durumda, tekil bir nesne yaratmak ve onu sürdürme sorumluluğu uygulamanın kendisindedir. Uygulamanın ilk başlarında bu nesne üretilir ve ihtiyacı olan her nesneye bu tekil nesne verilir. Bu yaklaşım hem test edilebilirlik hem de kod kalitesi açısından kesinlikle doğrudur.</p><h3>New Operatörü</h3><p>Bir işi yapmak için bir nesnenin yeni bir instance’ını oluşturmak da yine sorun teşkil eder.</p><p>Örneğin, aşağıdaki döngünün 404 gelmesi sonucu durup durmadığını test etmek için yazılımcının test web sunucusu kurması gerekir:</p><pre>using (var client = new HttpClient())<br>{<br>    HttpResponseMessage response;<br>    do<br>    {<br>        response = await client.GetAsync(uri);<br>        // Cevabı işle ve uri değişkenini güncelle...<br>    } while (response.StatusCode != HttpStatusCode.NotFound);<br>}</pre><p>Ancak, bazen newkesinlikle zararsızdır: Basit entity nesneleri yaratnak sorun çıkarmaz:</p><pre>var person = new Person(&quot;John&quot;, &quot;Doe&quot;, new DateTime(1970, 12, 31));</pre><h3>Static Metodlar</h3><p>Statik metodlar da yan etkileri olan veya sonucu tahmin edilemeyen davranışların kaynağıdır. Kolayca sıkı bağımlılıklar oluşturarak kodumuzu test edilemez hale getirirler.</p><p>Örneğin, aşağıdaki metodun davranışını doğrulamak için, unit testin environment değikenlerini düzenlemesi ve ekrana doğru çıktı verildiğinden emin olmak için console çıktısını okuması gerekir:</p><pre>void CheckPathEnvironmentVariable()<br>{<br>    if (Environment.GetEnvironmentVariable(&quot;PATH&quot;) != null)<br>    {<br>        Console.WriteLine(&quot;PATH environment değişkeni mevcut.&quot;);<br>    }<br>    else<br>    {<br>       Console.WriteLine(&quot;PATH environment değişkeni tanımlı değil.&quot;);<br>    }<br>}</pre><p>Ancak saf static fonksiyonlar sorun teşkil etmez: bu tarz fonksiyonların birleşiminden oluşan fonksiyonlar da sorun teşkil etmez. Örneğin:</p><pre>double Hypotenuse(double side1, double side2) { return Math.Sqrt(Math.Pow(side1, 2) + Math.Pow(side2, 2)); }</pre><h3>Unit Testin Faydaları</h3><p>Görüldüğü üzere, test edilebilir kod yazmak disiplin, konsantrasyon, ve ekstra efor gerektirir. Ancak, yazılım geliştirme işi, zaten karmaşık zihinsel aktivitelerden oluşur. Bu yüzden sürekli dikkat etmeli ve kabul gören uygulamalara bağlı çalışmalıyız.</p><p>Bunun sonucunda ise, yazılımcıların kodu okurken zihinlerini zorlamayacak, temiz, bakımı kolay, gevşek bağlı, tekrar kullanılabilir API’lar elde ederiz. Sonuç olarak test edilebilir kodun amacı yalnızca test edilebilirlik değil, anlaması, bakımı ve geliştirmesi kolay kodlar elde etmektir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dcd419c16a26" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unit Test Nedir, Neden Önemlidir ve İyi Bir Testin Özellikleri Nelerdir?]]></title>
            <link>https://medium.com/@mugrcn/unit-testing-nedir-neden-%C3%B6nemlidir-ve-i%CC%87yi-bir-testin-%C3%B6zellikleri-nelerdir-b45982d63d6e?source=rss-81486897c83f------2</link>
            <guid isPermaLink="false">https://medium.com/p/b45982d63d6e</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Ugur Can]]></dc:creator>
            <pubDate>Sun, 22 Jan 2023 17:51:57 GMT</pubDate>
            <atom:updated>2023-01-26T08:23:17.712Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9sUUP2_gYIVm_g9_.png" /></figure><p>Bu makalede, unit test’in ne olduğundan kısaca bahsederek, iyi bir unit test nasıl olmalıdır gibi konular hakkında temel çerçeveleri çizerek konuyu teorik olarak basitleştirmeye çalışacağım.</p><p>Unit testler iyi bir yazılımcının en temel aracıdır. Ancak bazen iyi bir unit test yazmak zor olabilir. Kendisinin ya da başkasının kodu için unit test yazarken zorlanan yazılımcılar, kendilerinin temel test bilgilerinden ve tekniklerinden yoksun olduklarını düşünürler. Ancak temel anlamda zor olan unit test yazmak değil, test edilebilir kod yazmaktır.</p><blockquote>Kod yazmak basittir, basit kod yazmak zordur.</blockquote><h3>Unit Test nedir?</h3><p>En basit haliyle unit test, uygulamamızın küçük bir bölümünün davranışını <strong>diğer parçalardan bağımsız olarak</strong> doğrulama metodudur. Tipik bir unit test 3 fazdan oluşur: İlk olarak, test edilmek istenilen kodu çalıştırmak için gereken parçalar hazır hale getirilir, sonra test edilmek istenilen asıl parça tetiklenir (genelde fonksiyon çağrımı yapılır) ve son olarak sonuç davranışı gözlemlenir. Eğer sonuç davranışı beklentilerimizi karşılıyorsa unit test geçer aksi halde test edilen kodun bir yerlerinde hata olduğu anlamına gelir. Bu fazlar, Arrange, Act ve Assert olarak bilinir kısaca AAA. Türkçe olarak belki de HHH kısaltması kullanabiliriz. Hazırlık, Harekete geçme, Haklı çıkarma (Sonuncu kelime biraz zorlama oldu, aslında beklediğimiz sonucun doğruluğunu kanıtlamak anlamında kullandım)</p><h3>Neden test otomasyonuna ihtiyaç var?</h3><p>Yazılım sistemleri karışık mekanizmalardır. Belirli bir amacı yerine getirmek için birlikte çalışan parçaların bir araya getirilmesi ile oluşurlar.</p><p>Olası parametrelerle olası her sonucun karşılandığı durumları manuel olarak test etmek imkansız ve sıkıcı bir iştir. Ayrıca, sonrasında kodda yapacağınız tüm değişikliklerin daha önceki beklentileri bozup bozmadığının baştan test edilmesi gerekir. Bu yüzden otomatik testler çok önem kazanmıştır.</p><p>Birçok otomatik test tipi vardır. Bunlardan en bilinenleri unit testler ve integration testlerdir. Unit testler, belirli bir bileşenin(kod parçacığı) yazılımcı tarafından verilen parametrelerle, beklenilen sonuçları almayı planladığımız testlerdir. Entegrasyon testleri ise, birden fazla bileşenin (dış bağımlılıklar) birlikte çalışarak ürettikleri sonuçları gözlemlemek için yapılan testlerdir.</p><h3>Neyi test etmeliyiz?</h3><p>Unit test yazmak, yazılım geliştiricilerden beklenen ve ciddi efor gerektiren bir iştir. Dolayısıyla bu eforu nereye harcamak gerektiğini bilmek önemlidir.</p><p>İdeal olarak projedeki tüm kodun test kapsamına dahil olması beklenir ancak özellikle hiç test olmayan ya da çok az test yazılmış kodlarda bu mümkün olmayabilir. Bu gibi durumlarda, şu anki yaptığınız işin kritik bileşenlerine odaklanmalısınız.</p><h3>İyi bir unit testin özellikleri nelerdir?</h3><h4>Tek bir bileşene odaklanmalı</h4><p>Bir unit test tek bir bileşene odaklanmalı. Aynı zamanda her bir unit test tek bir methodu test etmeli. (Methodların birbirleri ile olan ilişkileri test edilmediği sürece ki bu nadirdir).</p><h4>Okuması kolay olmalı</h4><p>Unit testlerin okuması kolay ve amacının net olması gerekir ki yazılımcılar hangi şartlarda neyi test ettiklerini kolayca anlayabilsinler. Bunu sağlamak için biraz önce bahsettiğim AAA deseni uygulanmaktadır.<br>Bir unit test 3 parçadan oluşur:</p><ul><li>Arrange</li><li>Act</li><li>Assert</li></ul><p>İlk olarak <strong>Arrange</strong> kısmında kurulum işlemleri yapılır. Yani aslında test yapacağımız methodun bağlı bulunduğu nesne ayağa kaldırılır ve test edilecek algoritmanın çalışabilmesi için gerekli olan veri hazırlanır.</p><p>İkinci olarak <strong>Act</strong> kısmında test edilecek method çağrımı yapılır.</p><p>Üçüncü olarak <strong>Assert</strong> kısmında çağrılan method sonrası beklenen değer(ler) belirtilir.</p><h4>Doğru isimlendirme</h4><p>İsimlendirme de önemli bir rol oynamaktadır. Test fonksiyonun isminden testin amacının ne olduğu ilk bakışta anlaşılmalıdır.</p><p>Farklı isimlendirme çeşitleri vardır. Ben aşağıdaki gibi bir desen kullanıyorum:<br>&lt;Methodİsmi&gt;_when_&lt;koşul&gt;_should&lt;beklenti&gt;</p><p>Örneğin:</p><ul><li>Add_WhenCalled_ReturnSumOfTheArguments</li><li>Max_WhenCalled_ReturnTheGreaterArgument</li><li>Max_WhenArgumentsAreNull_ThrowArgumentNullException</li></ul><h4>Hız</h4><p>Unit testler hızlı çalışmalıdır. Bunu başarmak için tüm dış bağımlılıkları(veritabanı, network, I/O) ayırarak yalnızca ilgili logic’in çalışması test edilmelidir. Dış bağımlılıklar integration test kapsamında değerlendirilmelidir. SOLID prensiplerine göre oluşturulan kodlar, zaman harcayan dış bağımlı işlemler ile sıkı sıkıya bağlı olmadıkları için test yazmak kolaylaşır.</p><h4>İzolasyon</h4><p>Unit testler birbirlerinden bağımsız olmalıdır. Çalışma sıraları testin başarılı olup olmamasını etkilememelidir.</p><p>Unit testler paylaşımlı kaynakları kullandıklarında birbirlerini etkileyebilmektedirler. Yazılımcılar her bir unit test sonrası sistemin durumunu temizlemelidir.</p><p>Unit test framework’leri setup ve teardown metodları ile geliştirmeye yardımcı olmaktadırlar.</p><h3>Sonuç</h3><p>Genel hatları ile unit test hakkında temel konseptlere değinmek istedim. Bir sonraki <a href="https://medium.com/@mugrcn/unit-test-test-edilebilir-kod-nas%C4%B1l-yaz%C4%B1l%C4%B1r-ve-neden-%C3%B6nemlidir-dcd419c16a26">yazımda</a>, uygulamalı olarak detaylara inmeye çalışacağım.</p><p>Okuduğunuz için teşekkürler…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b45982d63d6e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>