<?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 Atakan Gemici on Medium]]></title>
        <description><![CDATA[Stories by Atakan Gemici on Medium]]></description>
        <link>https://medium.com/@atakangemici?source=rss-ba05b059d0b2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*lrobdON6bsM9I-W3qNaOUw.jpeg</url>
            <title>Stories by Atakan Gemici on Medium</title>
            <link>https://medium.com/@atakangemici?source=rss-ba05b059d0b2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 11:43:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@atakangemici/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[.NET 10’da Bizi Bekleyen Yenilikler]]></title>
            <link>https://atakangemici.medium.com/net-10da-bizi-bekleyen-yenilikler-1d0f587d8599?source=rss-ba05b059d0b2------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d0f587d8599</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Atakan Gemici]]></dc:creator>
            <pubDate>Sun, 12 Oct 2025 15:41:34 GMT</pubDate>
            <atom:updated>2025-10-12T15:53:27.728Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7ElGGs86Lf9PDWDuFfkReA.jpeg" /></figure><p>Uzun yıllardır geliştiricisi olduğum .NET ekosisteminin kısaca gelişiminden bahsetmek istiyorum. Yıllar içinde geçirdiği büyük dönüşümlerle bugün kullandığımız en olgun haline ulaştı.</p><p>Elbette bu süreçte sadece avantajlarını değil, bazı dönemlerde sınırlayıcı yanlarını da yaşadık. Özellikle .NET Framework döneminde cross-platform desteğinin olmaması bizi birçok projede kısıtlıyordu.</p><p>.NET Core’un ilk sürümü çıktığında ekip olarak büyük bir heyecan yaşamıştık. Cross-platform desteğiyle yepyeni bir dünyanın kapıları açılmıştı. Ardından Prod ortamda binlerce kullanıcıya hizmet veren büyük bir projemizi .NET Core’a geçirdik.</p><p>Bu geçiş elbette kolay olmadı yeni yapıyı öğrenmek, bağımlılıkları yeniden düzenlemek, farklı bir ekosisteme alışmak zordu. Ama sonunda bu dönüşüm gerçekten motive edici bir deneyim oldu.</p><p>Bugün, “Core” ismini geride bırakan Microsoft, .NET platformunu her sürümde daha da olgunlaştırıyor. Ve şimdi, .NET 10 ile birlikte geliştiricileri yeniden heyecanlandıracak birçok yeniliği bizlere sunuyor.</p><blockquote>Bu yazıda bu yenilikleri ve .NET’in geleceğini şekillendiren teknolojileri anlatmak istiyorum.</blockquote><h4><strong>.NET’in Yolculuğu: Framework’ten .NET 10’a</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/828/1*2NHr0g_xuuD0r1hJnrmYqA.png" /></figure><p>.NET Core isminden “Core” kelimesinin kaldırılması, sadece bir isim değişikliği değil, birleşik ve tekil bir ekosistemin başlangıcıydı.</p><p>Bu adımla birlikte .NET, tüm platformları kapsayan bütünleşik bir yapı haline geldi. Bugün geldiğimiz noktada bu yaklaşımın tam anlamıyla oturduğunu ve olgunlaştığını görüyoruz.</p><h4><strong>Performans ve Runtime İyileştirmeleri</strong></h4><p>.NET 10, performans, kararlılık ve düşük bellek tüketimi konularında ciddi adımlar atıyor.</p><p><strong>JIT Dynamic PGO:</strong> Uygulama çalışırken hangi kod bölümlerinin sık çalıştığını analiz edip bu kısımları otomatik optimize ederek runtime performansını artırıyor.</p><p><strong>Garbage Collector (GC):</strong> Düşük bellekli ortamlarda (örneğin container tabanlı sunucularda) daha akıllı çalışarak gereksiz temizlik döngülerini azaltıyor.</p><p><strong>Threading &amp; Task Scheduling:</strong> Görevlerin CPU çekirdeklerine dağıtımı optimize edilip, bu da işlem yükünün daha dengeli dağılmasını sağlıyor.</p><p><strong>HTTP/3:</strong> Yeni protokol desteği sayesinde bağlantı kurulumu hızlandı, gecikme süreleri azaldı. Özellikle web API’lerinde ve Blazor uygulamalarında fark edilir hız artışı sağlıyor.</p><h4><strong>NativeAOT Tarafındaki Gelişmeler</strong></h4><p>.NET 10 ile birlikte NativeAOT artık olgunlaşmış durumda ve birçok senaryoda üretim ortamlarında kullanılabilecek seviyeye geldi.</p><p>Kısaca, normalde .NET uygulamaları çalışma anında (runtime) JIT tarafından derlenir. NativeAOT ise bu işlemi build (derleme) sırasında yapar yani uygulama, çalışmadan önce tamamen yerel makine koduna dönüştürülür.</p><p><strong>Bu yaklaşımın avantajları:</strong></p><ul><li>Uygulama çok daha hızlı başlar, çünkü runtime sırasında JIT derlemesi yapılmaz.</li><li>Oluşan binary dosyası daha küçüktür; gereksiz framework bileşenleri dışarıda bırakılır.</li><li>.NET yüklü olmayan sistemlerde bile doğrudan çalışabilir.</li></ul><p>Sonuç olarak .NET 10 ile birlikte NativeAOT, artık yalnızca deneysel bir alan değil, özellikle CLI araçları, mikroservisler ve edge uygulamaları için güçlü bir üretim stratejisi haline geldi.</p><h4><strong>C# 13 / 14 Tarafındaki Gelişmeler</strong></h4><p>.NET 10, C# 13’ü kararlı, C# 14’ü ise erken önizleme aşamasında sunacak.</p><p>Henüz tüm özellikler kesinleşmemiş olsa da bazı dikkat çekici yenilikler öne çıkıyor:</p><p><strong>Collection Expressions:</strong> [1, 2, ..numbers] gibi kısa koleksiyon tanımları (preview aşamasında).</p><p><strong>Primary Constructors:</strong> Sınıf yapıcılarının doğrudan class tanımına yazılabilmesi (preview aşamasında).</p><p><strong>Params Spans:</strong> Daha verimli parametre listeleri.</p><p><strong>Improved Pattern Matching:</strong> Daha güçlü match ifadeleri.</p><p><strong>Simplified Using Pattern:</strong> Daha sade kaynak yönetimi.</p><h4>.NET 10 ile Gelen Yeni Özellikler</h4><p><strong>Output Caching artık Minimal API’lerde destekleniyor:</strong> Artık sadece MVC değil, Minimal API tabanlı uygulamalarda da kullanılabiliyor. API yanıtları daha kolay cache’leniyor ve performans artıyor.</p><p><strong>SignalR WebSocket modunda %15’e kadar throughput artışı:</strong> WebSocket katmanı optimize edildi. Gerçek zamanlı (real-time) uygulamalarda daha düşük gecikme sağlanıyor.</p><p><strong>Blazor + NativeAOT entegrasyonu genişledi:</strong> WebAssembly projeleri NativeAOT ile derlenip daha hızlı başlatılabiliyor.</p><h4><strong>Entity Framework Core 10 Yenilikleri</strong></h4><ul><li><strong>Compiled Models:</strong> Kararlılığı artırıldı.</li><li><strong>Bulk Operations:</strong> Büyük veri işlemlerinde performans yükseldi.</li><li><strong>LINQ:</strong> Gereksiz SQL üretimleri azaltıldı.</li><li><strong>Provider Geliştirmeleri:</strong> Cosmos DB, PostgreSQL ve SQLite tarafında native destek genişletildi.</li></ul><h4>.Net 10 ile <strong>AI ve Cloud Entegrasyonları</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/955/1*C53LtxUnGtB1cgqENCE8WQ.png" /><figcaption>Bu alan hâlâ gelişim aşamasında; resmi sürümle birlikte desteklenen model sayısının artması bekleniyor.</figcaption></figure><p>Microsoft, .NET 10’la birlikte yapay zekâyı doğrudan SDK ekosistemine entegre etmeye başladı.</p><p>Yeni Microsoft.Extensions.AI paketleri sayesinde Azure AI, OpenAI, Phi-3 gibi modellerle ortak bir altyapı üzerinden çalışmak mümkün hale geliyor.</p><p>Ayrıca System.AI.Experimental namespace’i ile LLM (Large Language Model) tabanlı entegrasyonlar çok daha kolay test edilebiliyor.</p><h4><strong>Tooling ve SDK Geliştirmeleri</strong></h4><p><strong>dotnet new komutları kategori bazlı hale geldi: </strong>Artık proje şablonları ai-service, grpc-service, minimal-api gibi kategoriler altında listeleniyor.</p><p><strong>Crossgen2 optimizasyonu: </strong>NativeAOT build’lerinde varsayılan hale geldi.</p><p><strong>MSBuild performansı artırıldı:</strong> Incremental build sürelerinde hız artışı gerçekleşti.</p><p><strong>Container imajları hafifledi:</strong> SDK ve runtime imajları ortalama 15–20 MB daha küçük hale geldi. Bu da CI/CD süreçlerinde daha hızlı indirme ve yükleme süreleri ile daha düşük veri aktarım hacmi anlamına geliyor.</p><h4><strong>Sürüm Takvimi</strong></h4><p><strong>Preview 1 (Şubat 2025):</strong> Microsoft, .NET 10’un ilk önizleme sürümünü Şubat ayında yayımladı.</p><p><strong>Release Candidate 1 (Eylül 2025):</strong> RC1 sürümüyle birlikte performans ve AI entegrasyonlarına yönelik birçok iyileştirme sunuldu.</p><p><strong>Genel Erişim (Kasım 2025):</strong> Resmi genel sürümün Kasım 2025’te yayımlanması bekleniyor.</p><h4><strong>Son Söz</strong></h4><p>Sonuç olarak .NET ekosistemi her sürümde biraz daha olgunlaşıyor ve geliştiricilere daha fazla kontrol, hız ve esneklik sunuyor. Biz geliştiriciler için artık mesele sadece kod yazmak değil; bu gelişen ekosistem içinde mimarilerimizi sürekli optimize edip Microsoft’un .NET’te attığı AI adımlarını yakından takip ederek yeni çağa ayak uydurmak.</p><blockquote>Kısacası, .NET 10&#39;u sadece bir güncelleme değil geliştirme alışkanlıklarımızı bir adım öteye taşıyan bir dönüm noktası olarak görüyorum.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d0f587d8599" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[gRPC : Mikroservislerde Gerçek Zamanlı Yolculuk]]></title>
            <link>https://atakangemici.medium.com/grpc-mikroservislerde-ger%C3%A7ek-zamanl%C4%B1-yolculuk-19164d4b8bbd?source=rss-ba05b059d0b2------2</link>
            <guid isPermaLink="false">https://medium.com/p/19164d4b8bbd</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[grpc]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[Atakan Gemici]]></dc:creator>
            <pubDate>Mon, 25 Aug 2025 15:57:07 GMT</pubDate>
            <atom:updated>2025-09-28T08:37:23.681Z</atom:updated>
            <content:encoded><![CDATA[<h3>gRPC : Mikroservislerde Gerçek Zamanlı Yolculuk</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MfNvUgDHuvF5BmuhURUFOw.png" /></figure><p>Yazılım mimarilerinde ihtiyaçlar her geçen gün değişiyor. Artık neredeyse her proje, hatta aynı projenin farklı modülleri bile kendi kullanım senaryosuna göre farklı teknolojilere ihtiyaç duyabiliyor. Bu hızlı değişim, doğru teknoloji seçimini hem kritik hem de zor bir karar haline getiriyor. İşte tam da bu noktada, performans, tip güvenliği ve modern iletişim özellikleriyle öne çıkan <strong>gRPC</strong> karşımıza çıkıyor.</p><p>Bu yazıda gRPC’nin ne olduğunu, hangi durumlarda tercih edilebileceğini ve küçük bir <strong>PoC (Proof of Concept)</strong> uygulaması üzerinden nasıl çalıştığını paylaşacağım.</p><h4><strong>gRPC Nedir?</strong></h4><p>gRPC, Google tarafından geliştirilmiş bir <strong>Remote Procedure Call (RPC)</strong> framework’üdür. Temelinde <strong>HTTP/2</strong> ve <strong>Protobuf (Protocol Buffers)</strong> vardır.</p><h4><strong>Avantajları:</strong></h4><ul><li>REST’e göre çok daha küçük mesaj boyutu ve düşük gecikme</li><li>.proto dosyası sayesinde <strong>contract-first</strong> tip güvenliği</li></ul><p><strong>Dört farklı iletişim modeli:</strong></p><ul><li><strong>Unary RPC</strong> → tek istek, tek yanıt</li><li><strong>Server Streaming</strong> → tek istek, çok yanıt</li><li><strong>Client Streaming</strong> → çok istek, tek yanıt</li><li><strong>Bidirectional Streaming</strong> → çift yönlü sürekli iletişim</li></ul><h4><strong>POC Senaryosu</strong></h4><p>Gerçek bir e-ticaret senaryosundan ilham alalım:</p><ol><li><strong>Client</strong> → sipariş oluşturuyor (PlaceOrder).</li><li><strong>Server</strong> → siparişi kabul edip bir OrderId dönüyor.</li><li><strong>Client</strong> → aynı OrderId ile siparişin durumunu canlı izliyor.(SubscribeOrderStatus).</li><li><strong>Server</strong> → sipariş aşamalarını (PACKING → LABELING → IN_TRANSIT → OUT_FOR_DELIVERY → DELIVERED) streaming ile gönderiyor.</li></ol><p><strong>.proto Dosyası</strong></p><pre>syntax = &quot;proto3&quot;;<br>option csharp_namespace = &quot;OrderProto&quot;;<br><br>package orders;<br><br>message PlaceOrderRequest {<br>  string customer_id = 1;<br>  string sku         = 2;<br>  int32  quantity    = 3;<br>}<br><br>message PlaceOrderReply {<br>  string order_id = 1;<br>  string status   = 2;<br>}<br><br>message OrderStatusRequest {<br>  string order_id = 1;<br>}<br><br>message OrderStatusUpdate {<br>  string order_id = 1;<br>  string stage    = 2; <br>  int32  progress = 3; <br>}<br><br>service OrderService {<br>  rpc PlaceOrder (PlaceOrderRequest) returns (PlaceOrderReply);              <br>  rpc SubscribeOrderStatus (OrderStatusRequest) returns (stream OrderStatusUpdate);<br>}</pre><p><strong>Server Implementasyonu</strong></p><pre>public class OrderServiceImpl : OrderService.OrderServiceBase<br>{<br>    public override Task&lt;PlaceOrderReply&gt; PlaceOrder(PlaceOrderRequest request, ServerCallContext context)<br>    {<br>        var orderId = Guid.NewGuid().ToString(&quot;N&quot;);<br>        return Task.FromResult(new PlaceOrderReply<br>        {<br>            OrderId = orderId,<br>            Status = &quot;ACCEPTED&quot;<br>        });<br>    }<br><br>    public override async Task SubscribeOrderStatus(OrderStatusRequest request, IServerStreamWriter&lt;OrderStatusUpdate&gt; responseStream, ServerCallContext context)<br>    {<br>        var stages = new (string stage, int progress)[] {<br>            (&quot;PACKING&quot;, 10), (&quot;LABELING&quot;, 30), (&quot;IN_TRANSIT&quot;, 70), (&quot;OUT_FOR_DELIVERY&quot;, 90), (&quot;DELIVERED&quot;, 100)<br>        };<br><br>        foreach (var (stage, progress) in stages)<br>        {<br>            await responseStream.WriteAsync(new OrderStatusUpdate<br>            {<br>                OrderId = request.OrderId,<br>                Stage = stage,<br>                Progress = progress<br>            });<br><br>            await Task.Delay(1000, context.CancellationToken);<br>        }<br>    }<br>}</pre><p><strong>Client Kodları</strong></p><pre><br>var serverAddress = Environment.GetEnvironmentVariable(&quot;GRPC_SERVER&quot;) ?? &quot;http://localhost:5075&quot;;<br><br>using var channel = GrpcChannel.ForAddress(serverAddress);<br>var client = new OrderService.OrderServiceClient(channel);<br><br>var reply = await client.PlaceOrderAsync(new PlaceOrderRequest<br>{<br>    CustomerId = &quot;C-1001&quot;,<br>    Sku = &quot;SKU-ABC&quot;,<br>    Quantity = 2<br>});<br><br>Console.WriteLine($&quot;Order accepted: {reply.OrderId} ({reply.Status})&quot;);<br><br>using var call = client.SubscribeOrderStatus(new OrderStatusRequest { OrderId = reply.OrderId });<br><br>await foreach (var update in call.ResponseStream.ReadAllAsync())<br>{<br>    Console.WriteLine($&quot;[{update.OrderId}] {update.Stage} ({update.Progress}%)&quot;);<br>}</pre><p><strong>Ekran Çıktısı</strong></p><pre>Order accepted: 1db9b03915224a7090a8801fd3f371e0 (ACCEPTED)<br>[1db9b03915224a7090a8801fd3f371e0] PACKING (10%)<br>[1db9b03915224a7090a8801fd3f371e0] LABELING (30%)<br>[1db9b03915224a7090a8801fd3f371e0] IN_TRANSIT (70%)<br>[1db9b03915224a7090a8801fd3f371e0] OUT_FOR_DELIVERY (90%)<br>[1db9b03915224a7090a8801fd3f371e0] DELIVERED (100%)</pre><h4><strong>Çalışma Mantığı</strong></h4><p><strong>PlaceOrder (Unary RPC)</strong></p><ul><li>Client → “Bu üründen 2 adet sipariş veriyorum.”</li><li>Server → “Sipariş kabul edildi, işte OrderId.”</li><li>Tek request, tek response (REST POST’e benzer).</li></ul><p><strong>SubscribeOrderStatus (Server Streaming RPC)</strong></p><ul><li>Client → “Bu OrderId’nin durumunu takip etmek istiyorum.”</li><li>Server → Aşamaları sırayla gönderiyor (packing → delivered).</li><li>Tek request, <strong>birden fazla response</strong>.</li></ul><h4><strong>Gösterdiği Noktalar</strong></h4><ul><li><strong>gRPC</strong> <strong>contract-first</strong>: tüm mesajlar .proto dosyasından üretildi.</li><li><strong>Tip güvenliği</strong>: Client ve Server aynı tipleri paylaştı.</li><li><strong>Streaming kolaylığı</strong>: REST’te sürekli polling gerekirken gRPC server “push” yapıyor.</li><li><strong>Gerçek zamanlı kullanım örnekleri</strong>: sipariş takibi, video işleme ilerlemesi, IoT telemetry, uzun süren job takibi.</li></ul><h4><strong>REST vs Queue vs gRPC</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1008/1*F6vToRYjW1m2Xe10_egh1w.png" /></figure><h4><strong>Gerçek Hayattan Senaryolar</strong></h4><ul><li><strong>Sipariş takibi</strong>: Trendyol / Amazon → “hazırlanıyor / yolda / teslim edildi”</li><li><strong>Video işleme</strong>: Render % ilerlemesi</li><li><strong>IoT</strong>: Sensör verilerinin canlı akışı</li><li><strong>Chat</strong>: Streaming ile gerçek zamanlı mesajlaşma</li></ul><h4><strong>Sonuç</strong></h4><ul><li>gRPC, REST’in yerine geçmek için değil; mikroservis iletişimini hızlandırmak ve zenginleştirmek için var.</li><li>Streaming özelliği sayesinde “tek istek → canlı güncellemeler” senaryolarında çok güçlü.</li><li>Queue ve push notification gibi çözümlerle birlikte kullanıldığında tam bir mimari tamamlayıcı oluyor.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/0*Fpy7wszMMHgJiOpj.jpeg" /><figcaption>Microservis mimarilerinde, gRPC gerçek zamanlı iletişim için güçlü ve uygulanabilir bir seçenek olarak öne çıkıyor.</figcaption></figure><p><strong>Detaylı İnceleme için<br></strong>Örnek gRPC projesinin kaynak kodlarına GitHub üzerinden ulaşabilirsiniz: <a href="https://github.com/atakangemici/grpc-poc">https://github.com/atakangemici/grpc-poc</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=19164d4b8bbd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dağıtık Sistemlerde Kritik Bir Tercih: CAP Teoremi]]></title>
            <link>https://atakangemici.medium.com/da%C4%9F%C4%B1t%C4%B1k-sistemlerde-kritik-bir-tercih-cap-teoremi-7a32f6693311?source=rss-ba05b059d0b2------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a32f6693311</guid>
            <category><![CDATA[dağıtık-sistemler]]></category>
            <category><![CDATA[cap-teoremi]]></category>
            <category><![CDATA[yazılım-mimarisi]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Atakan Gemici]]></dc:creator>
            <pubDate>Tue, 22 Jul 2025 18:07:15 GMT</pubDate>
            <atom:updated>2025-07-22T18:27:31.907Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*TD8fNKdS1f3HXXZ2fReS0g.jpeg" /></figure><p>2000 yılında bilgisayar bilimcisi <strong>Eric Brewer</strong>, dağıtık sistemler için önemli bir gözlem ortaya koydu: <em>Bir dağıtık sistemde aynı anda hem tutarlılık, hem erişilebilirlik hem de ağ bölünme toleransı sağlanamaz.</em> Bu gözlem daha sonra <strong>CAP Teoremi</strong> adıyla anılmaya başladı ve günümüzde dağıtık sistem tasarımının temel taşlarından biri haline geldi.</p><p>Dağıtık sistemler, doğası gereği birbirinden bağımsız ama bir arada çalışarak tek bir sistem gibi davranmaya çalışan yapılardır. Günümüzde birçok teknoloji devi, geliştirdikleri sistemleri dağıtık mimariler üzerine kurguluyor. Bunun temel nedeni, olası bir arıza veya kesinti durumunda bile kullanıcılarına kesintisiz hizmet sunabilmek ve her koşulda erişilebilirliği sağlamaktır.</p><p>Dağıtık mimarilerin avantajları saymakla bitmez; ölçeklenebilirlik, yüksek erişilebilirlik ve hata toleransı bunlardan sadece birkaçıdır. Ancak tıpkı her mimari yaklaşımda olduğu gibi, dağıtık sistemlerde de bazı <strong>kritik tasarım kararları</strong> almak zorunda kalırsınız. İşte bugün sizlerle bu kararların merkezinde yer alan <strong>CAP Teoremi</strong> hakkında konuşacağız.</p><h3><strong>Bir Senaryo: E-Ticaret Sitesinde Stok Sorgulama</strong></h3><p>Diyelim ki büyük bir e-ticaret uygulamasından alışveriş yapmak istiyorsunuz. Ana sayfaya girdiniz, beğendiğiniz bir ürünü sepete eklemek istediniz. Şimdi kritik bir soru:</p><p><strong>Sepete ekle dediğinizde sistem ne yapmalı?</strong></p><ul><li>Size hemen ürünün sepete eklendiğini gösterip daha sonra stokta olup olmadığını kontrol eden bir sistem mi tercih edersiniz?</li><li>Yoksa sistem stok durumundan emin olamıyorsa, <strong>“Bu ürünü şu an ekleyemiyorum”</strong> diyerek işlem yapmayan bir yaklaşımı mı?</li></ul><p>İşte bu sorunun cevabı, CAP Teoremi bu durumu açıklar ve mimari tasarımcıları zor bir tercihle karşı karşıya bırakır.</p><h3><strong>CAP Teoremi Nedir?</strong></h3><p>CAP Teoremi, dağıtık bir sistemde <strong>ağ bölünmesi (Partition)</strong> yaşandığında, aynı anda şu üç özelliği birden sağlayamayacağımızı söyler:</p><h4><strong>Consistency (Tutarlılık)</strong></h4><p>Tüm node’lar (sunucular), her zaman aynı veriyi görür. Bir kullanıcı bir node’dan veri yazdıysa, diğer node’lardan okuyan tüm kullanıcılar aynı veriyi görmelidir.</p><h4><strong>Availability (Erişilebilirlik)</strong></h4><p>Sistem her isteğe bir yanıt vermelidir. Ağda bir problem olsa bile kullanıcıya ya veriyi ya da bir hata mesajını ulaştırır.</p><h4><strong>Partition Tolerance (Bölünme Toleransı)</strong></h4><p>Sistem, node’lar arasındaki ağ bağlantısı koptuğunda bile çalışmaya devam eder.</p><p><strong>Teorem der ki: </strong><em>“Partition olduğunda Consistency ve Availability’den sadece birini seçebilirsin.”</em></p><h3><strong>Partition Olduğunda Ne Olur?</strong></h3><p>Dağıtık sistemlerde ağ kopmaları kaçınılmazdır. Peki böyle bir durumda sistem nasıl davranır?</p><h4><strong>Tutarlılığı Öncelikli Tutarsak (CP):</strong></h4><p>Sistem, verinin tutarlılığından ödün vermez. Ağ kopmuşsa, işlemleri durdurur ve kullanıcıya yanıt vermez.</p><p><em>Avantaj: Veri her zaman doğru ve senkronizedir.</em></p><p><em>Dezavantaj: Kullanıcılar hizmet alamaz.</em></p><h4><strong>Erişilebilirliği Öncelikli Tutarsak (AP):</strong></h4><p>Sistem, her durumda kullanıcıya yanıt döner. Ancak node’lar arasındaki veri tutarsız olabilir.</p><p><em>Avantaj</em>: Kullanıcılar işlem yapmaya devam eder.</p><p><em>Dezavantaj</em>: Farklı kullanıcılar farklı node’larda tutarsız veriler görebilir.</p><blockquote><strong>İşte seçim yapmak zorunda kaldığımız nokta tam burasıdır.</strong></blockquote><h3>Gerçek Senaryolar</h3><h4>Tutarlılığı Öncelikli Sistemler (CP)</h4><p><strong>Amazon Sipariş Yönetimi</strong><br><em>Amazon’un sipariş veritabanın da, bir ağ bölünmesi (partition) yaşandı. Stokta son kalan ürünü satın almaya çalışan iki kullanıcı aynı anda sipariş veriyor.</em></p><p>Sistem, <strong>stok bilgisinin farklı veri merkezlerinde tutarsız olma ihtimaline karşı</strong>, <strong>her iki sipariş isteğini de geçici olarak reddediyor</strong> ve kullanıcıya şu uyarıyı gösteriyor:</p><blockquote>“Siparişiniz şu anda işlenemiyor. Lütfen birkaç dakika içinde tekrar deneyin.”</blockquote><p>Böylece <strong>veri tutarlılığı garanti altına alınıyor</strong>, ama kullanıcılar için <strong>erişilebilirlikten ödün verilmiş</strong> oluyor (işlem yapılamıyor).</p><h4>Erişilebilirliği Öncelikli Sistemler (AP)</h4><p><strong>YouTube İzleme Sayısı</strong><br>Bir video milyonlarca kişi tarafından izlenirken anlık görüntüleme sayısı biraz geriden gelebilir. Çünkü YouTube önce erişilebilirliği sağlar, sonra tutarlılığı toparlar.</p><p><strong>Instagram Beğeni Sayısı</strong><br>Bir gönderiyi beğendiğinizde, sunucuya ulaşmasa bile like sayısı artar. Bağlantı geldiğinde sistem tutarsızlıkları düzeltir.</p><h4>Tutarlılık + Erişilebilirlik Sistemleri (CA)</h4><p><strong>Online Bilet Siteleri </strong><br> Son koltuğu almak isteyen iki kişiden biri işlemi tamamlar, diğeri:</p><p><em>“Bilet kalmadı.”</em></p><p>Ağ koparsa sistem tamamen erişilemez hale gelir.</p><h3>Sonuç</h3><p>Dağıtık sistemler; esneklik, ölçeklenebilirlik ve yüksek erişilebilirlik gibi pek çok avantaj sunar. Ancak <strong>CAP Teoremi</strong>, bu sistemleri tasarlarken bazı zor seçimlerin kaçınılmaz olduğunu hatırlatır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*WRZbxnSrxa1k9GxegJ1UBg.jpeg" /></figure><blockquote>Tasarımlarınızda tutarlılığı mı, yoksa erişilebilirliği mi önceliklendirirsiniz? sorusu, dağıtık mimariler geliştiren herkesin mutlaka yanıtlaması gereken temel bir sorudur.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a32f6693311" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Clean Code Prensipleri]]></title>
            <link>https://atakangemici.medium.com/kodunuzu-temiz-tutun-clean-code-7a102c23446f?source=rss-ba05b059d0b2------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a102c23446f</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[best-practices]]></category>
            <dc:creator><![CDATA[Atakan Gemici]]></dc:creator>
            <pubDate>Sun, 19 Jan 2025 14:30:58 GMT</pubDate>
            <atom:updated>2025-08-07T11:48:48.985Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4kfby-fsKsdUF2tMxh5GSg.png" /></figure><p>Merhabalar, günümüz yazılım dünyası hızla gelişirken, kod yazma araçları ve yapay zeka destekli teknolojilerin etkisiyle birlikte, kod kalitesine verilen önemin giderek arttığını görmekteyiz. Yazılım geliştirme süreçlerinde kalitenin sağlanması ve sürdürülebilirliğin artırılması adına Clean Code (Temiz Kod) yaklaşımının ne denli önemli olduğunu vurgulamak istedim. Bu yazımda, Clean Code prensiplerine odaklanarak, yazılım geliştirme süreçlerinde daha kaliteli, anlaşılır ve sürdürülebilir kodlar yazmanın yollarını ele alacağım.</p><h3>Clean Code Nedir?</h3><p>Clean Code’un tanımı, yazılımcılar arasında farklı şekillerde yapılsa da ortak bir anlayış vardır:</p><p><strong>Kolay okunabilir, bakımı kolay ve sürdürülebilir kod</strong>.</p><p>Clean Code prensipleriyle yazılmış kodlar, ekip arkadaşlarınız tarafından kolayca anlaşılabilir, geliştirilebilir ve sürdürülebilir olur. Bu durum yalnızca ekip içi iletişimi kolaylaştırmakla kalmaz; aynı zamanda, üzerinden uzun zaman geçtikten sonra kendi yazdığınız kodu bile hızlı bir şekilde anlayabilmenizi sağlar. Adeta kodu yazdığınız ilk günkü gibi hatırlamanıza yardımcı olur.</p><blockquote>Şimdi Clean Code prensiplerini açıklayalım :)</blockquote><h3>Anlamlı İsimlendirmeler</h3><p>Yazılımda isimlendirme, kodun okunabilirliğini ve anlaşılabilirliğini artırır. Değişken, fonksiyon ve dosya isimleri yaptıkları işi net bir şekilde ifade etmelidir. Açıklayıcı, kısa ve tutarlı isimlendirmeler, kodun hem ekip arkadaşlarınız hem de sizin için daha kolay anlaşılmasını sağlar.</p><p><strong><em>Yanlış İsimlendirme:</em></strong></p><pre>int a = 10;<br>int b = 20;<br>int c = a + b;<br><br>void DoWork()<br>{<br>  Console.WriteLine(c);<br>}</pre><p><strong><em>Doğru İsimlendirme:</em></strong></p><pre>int firstNumber = 10;<br>int secondNumber = 20;<br>int sum = firstNumber + secondNumber;<br><br>void DisplaySum()<br>{<br>  Console.WriteLine(sum);<br>}</pre><h4><strong><em>Doğru İsimlendirme Prensipleri</em></strong></h4><ul><li><strong>Açıklayıcı ve Anlamlı İsimler: </strong>Değişken, fonksiyon ve sınıf isimleri, ne yaptığını net bir şekilde açıklamalıdır.</li><li><strong>Kısa ama Anlamlı İsimler: </strong>Gereksiz uzunluklardan kaçınılmalı, fakat anlamlı bir ifade korunmalıdır.</li><li><strong>İngilizce Kullanımı: </strong>İsimlendirme İngilizce olmalıdır.</li><li><strong>Pozitif ve Negatif Durumları Belirten İsimler: </strong>Eğer bir boolean değer varsa, doğru (true) ve yanlış (false) durumlarını ifade eden anlamlı isimler kullanılmalıdır.</li><li><strong>Sınıf ve Modül İsimleri Tekil ve Anlamlı Olmalı: </strong>Sınıf isimleri tekil ve neyi temsil ettiğini açıkça belirtmelidir.</li><li><strong>Açıklama Gerektirmeyen İsimler: </strong>Kodun kendisi anlaşılır olmalı, böylece gereksiz açıklamalara ihtiyaç duyulmaz.</li></ul><h3>Fonksiyonların Tek Bir İş Yapması</h3><p>Fonksiyonlar, yazılım geliştirmede en temel yapı taşlarından biridir. Clean Code prensiplerine göre, her fonksiyon yalnızca tek bir iş yapmalı ve bunu en kısa ve en anlaşılır şekilde gerçekleştirmelidir. Fonksiyonların uzun ve karmaşık olması, okunabilirliği azaltır ve bakımı zorlaştırır.</p><p><em>Bir fonksiyonun basit, net ve tek bir sorumluluğa sahip olması, hem kodun anlaşılmasını hem de gelecekte yapılacak güncellemeleri kolaylaştırır.</em></p><p><strong><em>Yanlış </em></strong><em>(Karmaşık ve birden fazla sorumluluğa sahip fonksiyon):</em></p><pre>public void ProcessOrder(Order order) {<br>   // Siparişi al<br>    ValidateOrder(order);<br>    SaveOrderToDatabase(order);<br><br>    // Siparişle ilgili ödeme işlemi<br>    ProcessPayment(order);<br><br>    // Kullanıcıya e-posta gönder<br>    SendEmailConfirmation(order);<br>}</pre><p><strong><em>Doğru </em></strong><em>(Tek bir sorumluluğa sahip fonksiyon):</em></p><pre>public void ValidateOrder(Order order) {<br>    // Siparişi doğrula<br>    if (order == null || order.Items.Count == 0)<br>        throw new InvalidOperationException(&quot;Order is invalid.&quot;);<br>}<br><br>public void SaveOrderToDatabase(Order order) {<br>    // Siparişi veritabanına kaydet<br>    _dbContext.Orders.Add(order);<br>    _dbContext.SaveChanges();<br>}<br><br>public void ProcessPayment(Order order) {<br>    // Ödeme işlemini yap<br>    _paymentService.Process(order.TotalAmount);<br>}<br><br>public void SendEmailConfirmation(Order order) {<br>    // E-posta onayı gönder<br>    _emailService.Send(order.CustomerEmail, &quot;Your order has been processed.&quot;);<br>}</pre><h4>Doğru Fonksiyon Prensipleri</h4><ul><li><strong>Tek Amaç:</strong> Her fonksiyon yalnızca bir işlev gerçekleştirmeli.</li><li><strong>Kısa ve Öz: </strong>Fonksiyonlar olabildiğince kısa ve öz olmalı.</li><li><strong>Anlamlı İsimler: </strong>Fonksiyon ismi yaptığı işi açıkça ifade etmeli.</li><li><strong>Tek Sorumluluk Prensibi (</strong>Single Responsibility Principle<strong>):</strong> Birden fazla işi bir arada yapan fonksiyonlardan kaçınılmalı.</li></ul><h3>Gereksiz Yorumlardan Kaçınma</h3><p>Kodun kendisi, ne yaptığını açıkça ifade edecek kadar anlaşılır olmalıdır. Clean Code prensiplerine göre, iyi yazılmış bir kod açıklama yapma ihtiyacını en aza indirir. Gereksiz veya aşırı kullanılan yorumlar, kodun okunabilirliğini azaltır ve zamanla yorumların koddan bağımsız hale gelmesine yol açabilir.</p><blockquote>Yorumlar bir zorunluluk değil, bir istisna olmalıdır. Kodun kendisi bir “yorum” gibi yazılmalıdır :)</blockquote><p><strong><em>Yanlış</em></strong><em> (Aşırı yorumlarla açıklama yapılmış):</em></p><pre>public void ProcessOrder(Order order) {<br>    // Siparişin geçerli olup olmadığını kontrol et<br>    if (order == null) {<br>        // Sipariş geçersiz, hata fırlat<br>        throw new ArgumentNullException(&quot;Order cannot be null&quot;);<br>    }<br><br>    // Siparişi veritabanına kaydet<br>    // Bu işlem, siparişin veritabanına eklenmesini sağlar<br>    _dbContext.Orders.Add(order);<br>    _dbContext.SaveChanges();<br><br>    // Ödeme işlemi başlat<br>    // Ödeme için ödeme servisimize başvurulacak<br>    _paymentService.ProcessPayment(order.TotalAmount);<br><br>    // Kullanıcıya sipariş onay e-postası gönder<br>    // Kullanıcıya sipariş onayı e-postası gönderilir<br>    _emailService.SendOrderConfirmation(order.CustomerEmail);<br>}</pre><p><strong><em>Doğru</em></strong><em> (Gereksiz yorumlardan kaçınılarak yazılmış kod):</em></p><pre>public void ProcessOrder(Order order) {<br>    if (order == null) {<br>        throw new ArgumentNullException(&quot;Order cannot be null&quot;);<br>    }<br><br>    _dbContext.Orders.Add(order);<br>    _dbContext.SaveChanges();<br><br>    _paymentService.ProcessPayment(order.TotalAmount);<br><br>    _emailService.SendOrderConfirmation(order.CustomerEmail);<br>}</pre><h4>Doğru Yorum Prensipleri</h4><ul><li><strong>Anlaşılır İsimlendirme Tercih Edin:</strong> Kodun kendisi açıklayıcı olmalı, bu sayede yoruma gerek kalmamalı.</li><li><strong>Kötü Tasarımı Açıklamak Yerine Düzeltin:</strong> Yorumlarla kötü bir çözümü açıklamak yerine, kodu daha iyi hale getirin.</li><li><strong>Gerçekten Gerekliyse Yorum Yapın:</strong> Karmaşık algoritmalar, iş kuralları veya neden bazı kararlar alındığını açıklamak için yorum ekleyin.</li></ul><h3>Kodda Tekrardan Kaçınma (DRY Prensibi)</h3><p>Clean Code’un önemli prensiplerinden biri olan DRY (Don’t Repeat Yourself), aynı kodu birden fazla yerde tekrar etmek yerine, ortak fonksiyonlar veya dinamik yapılar kullanarak kod tekrarını önlemeyi hedefler. Tekrarlanan kod, bakım zorluğu yaratır ve hataya açık hale gelir. DRY prensibi, kodun daha modüler, okunabilir ve kolayca yönetilebilir olmasını sağlar.</p><h4>DRY(Don’t Repeat Yourself) Prensibi</h4><ul><li><strong>Ortak Fonksiyonlar Oluşturun:</strong> Tekrarlayan işlemleri bir fonksiyonda toplayın.</li><li><strong>Parametreler Kullanarak Dinamik Yapılar Tasarlayın:</strong> Kodun esnekliğini artırın.</li><li><strong>Kodunuzu Modüler Hale Getirin:</strong> Benzer işlevleri sınıflar veya bileşenler halinde gruplayın.</li><li><strong>Kütüphanelerden Yararlanın:</strong> Halihazırda çözüm sunan araçlar ve kütüphaneleri kullanın.</li></ul><p><strong><em>Yanlış </em></strong><em>(Aynı işlemi farklı yerlerde tekrar etmek):</em></p><pre>Console.WriteLine(&quot;Hello, John!&quot;);<br>Console.WriteLine(&quot;Hello, Sarah!&quot;);<br>Console.WriteLine(&quot;Hello, Michael!&quot;);</pre><p><strong><em>Doğru </em></strong><em>(Ortak bir fonksiyon ile tekrarı önlemek):</em></p><pre>void GreetUser(string name)<br>{<br>    Console.WriteLine($&quot;Hello, {name}!&quot;);<br>}</pre><h3>Anlamlı Hata Yönetimi</h3><p>Hatalar yazılımın doğal bir parçasıdır ve doğru bir şekilde ele alınmazsa hem kullanıcı deneyimini hem de sistemin güvenilirliğini olumsuz etkileyebilir. <strong>Clean Code</strong> prensiplerine göre, hata mesajları kullanıcıyı net bir şekilde bilgilendirmeli ve geliştiricilerin hatayı bulmasını kolaylaştırmalıdır. Bunun için anlamlı hata mesajları, özel istisnalar ve global hata yakalama mekanizmaları kullanılmalıdır.</p><p><strong><em>Yanlış:</em></strong></p><pre>public void ProcessOrder(int orderId)<br>{<br>    if (orderId &lt;= 0)<br>    {<br>        throw new Exception(&quot;Error&quot;);<br>    }<br>}</pre><p><strong><em>Doğru:</em></strong></p><pre>public void ProcessOrder(int orderId)<br>{<br>    if (orderId &lt;= 0)<br>    {<br>        throw new ArgumentException(&quot;Order ID must be greater than zero.&quot;);<br>    }<br>}</pre><h4>Doğru Hata Yönetimi Prensipleri</h4><ul><li><strong>Anlamlı Hata Mesajları:</strong> Kullanıcıya hatanın ne olduğunu ve nasıl çözülebileceğini açıklayan mesajlar sağlayın.</li><li><strong>Özel İstisnalar:</strong> Projenize uygun özel istisna sınıfları tanımlayın.</li><li><strong>Global Hata Yakalama:</strong> Hataları merkezi bir yerde yakalayarak hem kullanıcıya hem de log sistemine yönlendirin.</li><li><strong>Kritik Bilgiyi Gizleme:</strong> Kullanıcıya yalnızca gerekli bilgiyi gösterin, sistemle ilgili kritik detayları paylaşmayın.</li><li><strong>Günlükleme (Logging):</strong> Hataları loglayarak geliştiricilere detaylı bilgi sunun.</li></ul><h3>Kodun Modüler Olması</h3><p>Kodun modüler yazılması, bağımsız ve soyutlanmış bileşenler oluşturur. Her bileşen kendi içinde anlamlı olup, bir araya geldiğinde uyumlu çalışır. Bu yapı, kodun esnek ve sürdürülebilir olmasını sağlar. Modüler yaklaşım, değişikliklerin yalnızca ilgili modülü etkilemesini sağlar ve sistemin daha kolay yönetilmesine olanak tanır.</p><p><strong><em>Yanlış</em></strong><em> (Modüler Olmayan Kod):</em></p><pre>public class UserService<br>{<br>    public void CreateUser(string username)<br>    {<br>        // Kullanıcıyı oluşturma işlemi<br>        Console.WriteLine(&quot;User created: &quot; + username);<br><br>        // E-posta gönderme işlemi burada yapılmakta<br>        Console.WriteLine(&quot;Sending email to &quot; + username);<br>    }<br>}</pre><p><strong><em>Doğru</em></strong><em> (Modüler Kod):</em></p><pre>public class UserService<br>{<br>    private readonly IEmailService _emailService;<br><br>    public UserService(IEmailService emailService)<br>    {<br>        _emailService = emailService;<br>    }<br><br>    public void CreateUser(string username)<br>    {<br>        // Kullanıcıyı oluşturma işlemi<br>        Console.WriteLine(&quot;User created: &quot; + username);<br><br>        // E-posta gönderme işlemi artık başka bir sınıfta yapılıyor<br>        _emailService.SendEmail(username);<br>    }<br>}<br><br>public interface IEmailService<br>{<br>    void SendEmail(string username);<br>}<br><br>public class EmailService : IEmailService<br>{<br>    public void SendEmail(string username)<br>    {<br>        Console.WriteLine($&quot;Sending email to {@example.com&quot;&gt;username}@example.com&quot;);<br>    }<br>}</pre><h4>Modülerlik Prensipleri</h4><ul><li><strong>Tek Bir Sorumluluk:</strong> Her modül, yalnızca tek bir sorumluluğa odaklanmalı.</li><li><strong>Bağımsız Çalışabilme:</strong> Modüller birbiriyle çok sıkı bir şekilde bağlı olmamalıdır.</li><li><strong>Yeniden Kullanılabilirlik:</strong> Modüller bir kez yazıldığında, farklı yerlerde kolayca kullanılabilmelidir.</li><li><strong>Test Edilebilirlik:</strong> Modüler yapılar, her bir modülün bağımsız olarak test edilmesine olanak tanır.</li></ul><h3>Tek Sorumluluk Prensibi (Single Responsibility Principle)</h3><p>Her sınıf veya modül yalnızca bir sorumluluğa sahip olmalıdır. Birden fazla sorumluluk yüklenen sınıflar, bu sorumlulukları yerine getirirken karmaşıklığa yol açar ve kodun bakımını zorlaştırır. SRP’ye göre, her sınıf veya modül tek bir iş yapmalı ve bu işte mükemmel olmalıdır. Eğer bir sınıf iki farklı sorumluluğa sahipse, bu sorumluluklar birbirinden bağımsız olamayabilir ve birindeki değişiklik diğerini olumsuz etkileyebilir.</p><p><strong>Bir örnekle açıklamak gerekirse:</strong></p><p><em>Eğer bir sınıf hem kullanıcı girişlerini doğruluyor hem de veritabanına kayıt yapıyorsa, bu sınıfın sorumlulukları birbirinden bağımsız olmayacaktır ve değişikliklerin yönetilmesi zorlaşacaktır. Tıpkı bir öğretmenin hem matematik hem de tarih dersi vermesi gibi, iki farklı sorumluluk bir arada olursa, ana konuya odaklanmak zorlaşır.</em></p><p><strong><em>Yanlış</em></strong><em> (SRP’yi Uymayan Kod):</em></p><pre>public class OrderService<br>{<br>    public void CreateOrder(Order order)<br>    {<br>        // Sipariş oluşturma işlemi<br>        Console.WriteLine(&quot;Order created for &quot; + order.CustomerName);<br>        <br>        // Sipariş raporunu oluşturma işlemi<br>        Console.WriteLine(&quot;Generating order report for &quot; + order.CustomerName);<br>    }<br>}</pre><p><strong><em>Doğru </em></strong><em>(SRP’yi Uyan Kod):</em></p><pre>public class OrderService<br>{<br>    private readonly IReportService _reportService;<br><br>    public OrderService(IReportService reportService)<br>    {<br>        _reportService = reportService;<br>    }<br><br>    public void CreateOrder(Order order)<br>    {<br>        // Sipariş oluşturma işlemi<br>        Console.WriteLine(&quot;Order created for &quot; + order.CustomerName);<br><br>        // Sadece raporlama sorumluluğu başka bir sınıfta<br>        _reportService.GenerateOrderReport(order);<br>    }<br>}<br><br>public interface IReportService<br>{<br>    void GenerateOrderReport(Order order);<br>}<br><br>public class ReportService : IReportService<br>{<br>    public void GenerateOrderReport(Order order)<br>    {<br>        // Sipariş raporunu oluşturma işlemi<br>        Console.WriteLine(&quot;Generating order report for &quot; + order.CustomerName);<br>    }<br>}</pre><h4>Single Responsibility Principle</h4><ul><li><strong>Bir Sınıf, Bir İş:</strong> Sınıflar yalnızca bir sorumluluğa sahip olmalı.</li><li><strong>Karmaşıklığı Azaltın:</strong> Sınıfları, her biri bir sorumluluğa odaklanacak şekilde tasarlanmalı.</li><li><strong>Bağımsız Değişiklik:</strong> Her sorumluluk değiştiğinde yalnızca ilgili sınıf etkilenmeli.</li><li><strong>Modülerlik:</strong> Her sınıfın amacı net ve spesifik olmalı.</li></ul><h3>Kod Formatlama ve Tutarlılık</h3><p>Kodun okunabilirliği, anlaşılabilirliği ve sürdürülebilirliği için tutarlı bir formatta yazılması çok önemlidir. İyi formatlanmış bir kod, yazılımcıların kodu daha hızlı anlamasına, hata yapma olasılığının azalmasına ve işbirliği süreçlerinin daha verimli olmasına olanak tanır. Kodun <strong>standart bir biçimde</strong> yazılması, özellikle ekip çalışması yaparken büyük önem taşır.</p><p><strong><em>Yanlış </em></strong><em>(Formatlama ve Tutarlılığın Olmaması):</em></p><pre>public class UserService {<br>  public void CreateUser(string username)<br>  {<br>    Console.WriteLine(&quot;Creating user: &quot; + username);<br>  }<br>  public void DeleteUser(string username) {<br>  Console.WriteLine(&quot;Deleting user: &quot; + username);  <br> }<br>}</pre><p><strong><em>Yanlış </em></strong><em>(Formatlama ve Tutarlılığın Olması):</em></p><pre>public class UserService<br>{<br>    public void CreateUser(string username)<br>    {<br>        Console.WriteLine(&quot;Creating user: &quot; + username);<br>    }<br><br>    public void DeleteUser(string username)<br>    {<br>        Console.WriteLine(&quot;Deleting user: &quot; + username);<br>    }<br>}</pre><h4>Ekip İçi Kod Standardı:</h4><ul><li><strong>İndentasyon: </strong>Tutarlı girintiler kullanın (genellikle 2–4 boşluk).</li><li><strong>Boşluklar: </strong>Operatörler ve parantezler etrafında boşluk bırakın.</li><li><strong>Satır Uzunluğu: </strong>Satırlar çok uzun olmamalı.</li><li><strong>Yorumlar: </strong>Kodun karmaşık kısımlarını açıklayın, gereksiz yorumlardan kaçının.</li><li><strong>İsimlendirme: </strong>Anlamlı ve tutarlı isimler kullanın.</li></ul><h3>Bağımlılıkların Yönetimi (Dependency Injection)</h3><p>Kod yazarken, bileşenlerin birbirine olan bağımlılıklarını yönetmek çok önemlidir. Bağımlılıkları doğrudan kod içerisinde yaratmak yerine, dışarıdan enjekte etmek daha temiz ve sürdürülebilir bir yapı sağlar. İşte burada Dependency Injection (DI) devreye girer.</p><p>DI, sınıfların ihtiyaç duyduğu bağımlılıkları dışarıdan almasını sağlar. Yani, bir sınıf başka bir sınıfın nesnesini kendisi yaratmak yerine, dışarıdan bu nesne kendisine verilir. Bu yaklaşım kodun daha esnek, test edilebilir ve bakımının daha kolay olmasını sağlar.</p><p><strong><em>Yanlış </em></strong><em>(Bağımlılıkların Yönetilemez Olması):</em></p><pre>public class UserService<br>{<br>    private EmailService _emailService = new EmailService(); // Doğrudan bağımlılık<br><br>    public void CreateUser(string username)<br>    {<br>        Console.WriteLine(&quot;Creating user: &quot; + username);<br>        _emailService.SendEmail(username); // E-posta gönderme işlemi<br>    }<br>}<br><br>public class EmailService<br>{<br>    public void SendEmail(string username)<br>    {<br>        Console.WriteLine(&quot;Sending email to &quot; + username);<br>    }<br>}</pre><p><strong><em>Yanlış </em></strong><em>(Bağımlılıkların Yönetilebilir Olması):</em></p><pre>public class UserService<br>{<br>    private readonly IEmailService _emailService;<br><br>    // Constructor üzerinden bağımlılık enjeksiyonu yapılır<br>    public UserService(IEmailService emailService)<br>    {<br>        _emailService = emailService;<br>    }<br><br>    public void CreateUser(string username)<br>    {<br>        Console.WriteLine(&quot;Creating user: &quot; + username);<br>        _emailService.SendEmail(username); // E-posta gönderme işlemi<br>    }<br>}<br><br>public interface IEmailService<br>{<br>    void SendEmail(string username);<br>}<br><br>public class EmailService : IEmailService<br>{<br>    public void SendEmail(string username)<br>    {<br>        Console.WriteLine(&quot;Sending email to &quot; + username);<br>    }<br>}</pre><h4><strong>Dependency Injection (DI) Prensipleri:</strong></h4><ul><li><strong>Bağımlılıkları Dışarıdan Sağlama: </strong>Bir sınıfın ihtiyaç duyduğu bağımlılıklar dışarıdan (constructor, method veya property üzerinden) sağlanmalıdır.</li><li><strong>Soyutlama Kullanımı: </strong>Bağımlılıklar somut sınıflar yerine arayüzler (interfaces) ya da soyut sınıflar üzerinden sağlanmalıdır.</li><li><strong>Sınıfların Bağımlılıklardan Bağımsız Olması: </strong>Sınıf, kendi ihtiyaç duyduğu bağımlılıkları kendisi yaratmamalıdır.</li><li><strong>Tek Sorumluluk Prensibi (SRP): </strong>Bağımlılık enjeksiyonu, sınıfların sadece bir sorumluluğa sahip olmasını sağlar ve karmaşayı engeller.</li><li><strong>Zayıf Bağlantılar (Loose Coupling): </strong>Sınıflar arasındaki bağlar zayıf olmalıdır. DI, sınıfların birbirlerinden bağımsız çalışmasını sağlar.</li><li><strong>Test Edilebilirlik: </strong>DI sayesinde, sınıfların bağımlılıkları kolayca taklit edilebilir (mock) hale gelir, bu da birim testlerini kolaylaştırır.</li><li><strong>Kapsülleme: </strong>Bağımlılıkları dışarıdan sağlamak, sınıfın iç yapısını dış dünyadan saklar ve yalnızca gerekli olan işlevlerin dışa açık olmasını sağlar.</li></ul><h3>Birim Test Yazımı</h3><p>Birim testleri, yazdığınız kodun doğru çalışıp çalışmadığını kontrol etmenin en etkili yoludur. Her fonksiyonun ve sınıfın doğru çalışıp çalışmadığını test etmek, yazılım geliştirme sürecinde kritik bir adımdır. Birim testleri yazmak, sadece mevcut kodun doğru çalıştığını doğrulamakla kalmaz, aynı zamanda ileride yapılacak değişikliklerin eski kodu bozup bozmadığını kontrol etmenizi sağlar.</p><blockquote>Daha fazla bilgi ve detaylı anlatım için aşağıdaki yazıma göz atabilirsiniz :)</blockquote><p><a href="https://atakangemici.medium.com/unit-test-d1bc7b51f381">Unit Test</a></p><h3>Performans ve Optimizasyon</h3><p>Kod yazarken yalnızca işlevsel olmasına odaklanmak yeterli değildir; aynı zamanda performans açısından da verimli olması gerekir. Performans, yazılımın hızını, kaynak tüketimini ve genel verimliliğini etkileyen kritik bir faktördür. Gereksiz işlemlerden ve kaynak kullanımından kaçınarak yazılımınızın daha hızlı ve verimli çalışmasını sağlayabilirsiniz.</p><p>Optimizasyon yaparken doğru dengeyi bulmak önemlidir. Performans iyileştirmeleri yaparken, kodun okunabilirliğinden ve sürdürülebilirliğinden ödün vermemek gerekir.</p><p>SonarQube, New Relic, Prometheus, Grafana ve AppDynamics gibi araçlar, yazılım uygulamalarının performansını izlemek ve optimize etmek için güçlü platformlar sunar. Bu araçlar, sistemin her aşamasında potansiyel sorunları tespit etmeye ve iyileştirme fırsatlarını belirlemeye yardımcı olur.</p><ul><li><strong>SonarQube</strong>: Kod kalitesini analiz eder, performans iyileştirmeleri ve güvenlik açıklarını tespit eder.</li><li><strong>New Relic</strong>: Gerçek zamanlı izleme yaparak uygulama ve sunucu performansını takip eder, kullanıcı deneyimini iyileştirir.</li><li><strong>Prometheus &amp; Grafana</strong>: Zaman serisi verilerini toplayarak sistemin performansını izler ve görselleştirir.</li><li><strong>AppDynamics</strong>: Uygulama içindeki her işlemi izleyerek performans sorunlarını tespit eder ve çözüm önerileri sunar.</li></ul><h3>Kod İncelemeleri ve Geri Bildirim</h3><p>Kodlama adımından sonra, ekip arkadaşlarınızdan geri bildirim almak çok önemlidir. Bu süreç, yazdığınız kodun kalitesini artırmak ve olası hataları erken tespit etmek için etkili bir yoldur. Düzenli kod incelemeleri yaparak, herkesin aynı standartlara uygun çalışmasını sağlayabilir ve daha verimli, hatasız kodlar üretebilirsiniz. Ekip içindeki bilgi paylaşımı, daha kaliteli kodlar yazmanıza yardımcı olur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*uUeHH5uRsHfXEsDY.jpg" /></figure><blockquote>Bu prensipleri uygulamak, kodun kalitesini artırmakla kalmaz, aynı zamanda geliştirme sürecini daha verimli ve keyifli hale getirir. Umarım yazım, size faydalı olmuştur. Keyifli kodlamalar dilerim! :)</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a102c23446f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unit Test]]></title>
            <link>https://atakangemici.medium.com/unit-test-d1bc7b51f381?source=rss-ba05b059d0b2------2</link>
            <guid isPermaLink="false">https://medium.com/p/d1bc7b51f381</guid>
            <category><![CDATA[xunit]]></category>
            <category><![CDATA[net-core]]></category>
            <category><![CDATA[test]]></category>
            <category><![CDATA[code-coverage]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Atakan Gemici]]></dc:creator>
            <pubDate>Mon, 13 Jan 2025 09:58:06 GMT</pubDate>
            <atom:updated>2025-01-15T16:22:27.843Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Yazılım Geliştirmede Unit Test’in Önemi</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/608/0*obhTPInN_Lze6Jw_.png" /><figcaption><strong>Test All The Things :)</strong></figcaption></figure><p>Merhabalar bugün sizlere, Unit Test (Birim Testi) konusunu uygulamalı bir şekilde anlatmaya çalışacağım. Test süreçleri, yazılım geliştirme sürecinin ayrılmaz bir parçasıdır ve profesyonel yazılım şirketlerinde test uzmanları bulunsa da, her yazılım geliştiricisinin test konusundaki sorumlulukları büyüktür. Yazılım geliştirirken kodun test edilebilir olması, geliştirme sürecinin başından itibaren düşünülmesi gereken önemli bir konudur. Bir yazılımcı sadece işlevsel kod yazmakla kalmamalı, aynı zamanda yazdığı kodun test edilebilir ve sürdürülebilir olmasını sağlamalıdır.</p><blockquote>Bu yazıda, Unit Test’in önemini, nasıl yardımcı olduğunu ve uygulamalı bir şekilde örnek senaryo üzerinden Unit Test nasıl entegre edebileceğimizi adım adım inceleyeceğiz :)</blockquote><h4><strong>Unit Test Nedir?</strong></h4><p>Unit test, yazılımın küçük birimlerini test ederek her bir parçanın doğru çalışıp çalışmadığını kontrol eden bir test yöntemidir. Kodun güvenilirliğini ve kalitesini artıran, gelecekte karşılaşabileceğiniz problemlere karşı önceden önlem almanızı sağlayan bir yaklaşımdır.</p><h4><strong>Unit Test Neden Önemlidir?</strong></h4><p>Unit test, yazılım geliştirme sürecinde büyük bir rol oynar çünkü kodun her bir parçasının doğru çalışıp çalışmadığını doğrulamaya yardımcı olur. Bu, hataların erken tespit edilmesini sağlar, böylece daha büyük sorunlar oluşmadan çözülür. Ayrıca, unit testler yazılımın bakımını kolaylaştırır, yeni özellikler eklerken mevcut kodun bozulmasını engeller ve yazılımın güvenilirliğini artırır. Son olarak, sürekli entegrasyon süreçlerinde kritik bir yer tutar ve kodun sürekli olarak sağlam kalmasını sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-dO5o6dPItgx4pHf.png" /><figcaption><strong>Software Development Life Cycle</strong></figcaption></figure><p>Kod geliştirme yaşam döngüsünde test, genellikle son aşama olarak düşünülse de, geliştirdiğimiz kodun test edilebilir olması gibi konular bir geliştiricinin yazdığı kod sırasında göz önünde bulundurması gereken önemli unsurlardandır.</p><h4><strong>Test Edilebilir Kod Yazmak</strong></h4><p>Unit testleri yazabilmek için öncelikle test edilebilir kod yazmak çok önemlidir. Yazılım geliştirirken, her bir işlevin bağımsız bir şekilde test edilebilir olmasına dikkat etmeliyiz. Bağımlılıklar, global değişkenler veya statik sınıflar gibi test edilmesi zor yapılar, testlerin etkinliğini olumsuz yönde etkileyebilir. Bu nedenle, kodu test edilebilir bir şekilde yazmak, testlerin başarısı için kritik bir adımdır.</p><blockquote>Şimdi, kullanıcıların kayıt işlemlerini gerçekleştirebileceği bir senaryo üzerinden nasıl Unit Test yazılacağını adım adım göstereceğim :)</blockquote><h4><strong>Kullanıcı Kayıt Senaryosu</strong></h4><p>Kullanıcıdan alınacak bilgiler şunlardır: isim, soyisim, telefon numarası ve şifre. Her bir bilgi, belirli validasyonlardan geçirilerek kontrol edilecek ve kullanıcıya doğrulama mesajları gösterilecektir.</p><h4><strong>Senaryo Akışı:</strong></h4><ol><li>Kullanıcıdan isim istenir. Eğer isim boşsa ya da 3 karakterden kısa ise, hata mesajı gösterilir ve işlem durdurulur.</li><li>Soyisim istenir ve yine benzer şekilde geçerliliği kontrol edilir. Eğer soyisim geçerli değilse, hata mesajı gösterilir ve işlem sonlandırılır.</li><li>Kullanıcıdan telefon numarası istenir. Telefon numarası 10 haneli değilse, geçersiz olduğu belirtilir ve işlem sonlandırılır.</li><li>Son olarak şifre istenir. Şifre 8 karakterden kısa ise geçersiz sayılır ve kullanıcıya hata mesajı gösterilir.</li><li>Tüm bilgiler geçerliyse, “Kayıt başarılı” mesajı gösterilir.</li></ol><p>Akışımızı daha anlaşılır ve görsel olarak daha kolay takip edilebilir bir hale getirmek için UML Diagramları kullanacağız. UML (Unified Modeling Language) Diagramları, yazılımın yapılarını, işleyişini ve etkileşimlerini görsel olarak temsil eden bir araçtır. Bu diagramlar sayesinde, sürecin her adımını daha net bir şekilde göstererek, test yazımını ve akışın nasıl işlediğini daha iyi anlayabiliriz.</p><blockquote><em>İlk olarak, kullanıcı kaydı (Register) sürecine dair bir Use Case diagramı oluşturacağız. Bu diagram, kullanıcının kaydolma işleminin nasıl yapılacağına dair tüm adımları basitçe gösterecek. Ardından, akışın her aşamasını temsil eden Activity Diagram’ları da ekleyerek, sürecin mantığını adım adım takip edebiliriz.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/421/1*6N3O3A_DspTVKH55tGgbSA.png" /><figcaption>UML Akış Diagramı</figcaption></figure><h4><strong>Proje Oluşturma ve Unit Test Entegrasyonu</strong></h4><p>Şimdi, yazdığımız bu teorik bilgileri uygulamaya dökelim. Bir <strong>Console Application</strong> başlatarak, kullanıcı kayıt işlemleri (register) üzerinde <strong>Unit Test</strong> yazma sürecini adım adım inceleyeceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8hclito-xvB7twFs-iV5Rg.png" /></figure><h4><strong>1. Proje Yapısını Oluşturma</strong></h4><p>İlk olarak, uygulama ve test projelerimizi organize edeceğiz. İki ana klasör (App ve Tests) oluşturacağız ve her birini uygun şekilde yapılandıracağız.</p><ol><li><strong>App</strong>: Kullanıcı girişini ve doğrulama işlemlerini yapan temel uygulama.</li><li><strong>Tests</strong>: Yazdığımız uygulamanın doğru çalıştığını doğrulamak için yazacağımız Unit Testler.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/417/1*YHuiOJpNh-zrJXt20_6vVw.png" /></figure><p>Uygulama klasöründe gerekli sınıfları oluşturacağız. Bu sınıflar şunlar olacak:</p><ul><li><strong>UserRegister</strong>: Kullanıcı kayıt işlemlerini yöneten sınıf.</li><li><strong>UserInput</strong> ve <strong>UserOutput</strong>: Kullanıcıdan alınan bilgileri işleyip çıktı verecek sınıflar.</li><li><strong>IUserRegister</strong>: UserRegister sınıfının implement edeceği interface.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IG-Nx7Yvz6O6dFeVd6FMyQ.png" /></figure><h4><strong>2. Register User ve Validasyonlar</strong></h4><p>Kodumuza kullanıcıdan alınacak bilgilerin validasyonlarını ekleyeceğiz:</p><ul><li><strong>İsim:</strong> 3 karakterden kısa olmamalı.</li><li><strong>Soyisim:</strong> 3 karakterden kısa olmamalı.</li><li><strong>Telefon Numarası:</strong> 10 haneli olmalı.</li><li><strong>Parola:</strong> 8 karakterden kısa olmamalı.</li></ul><blockquote>Bu validasyonlar kullanıcıdan alınan bilgilerin doğru ve geçerli olmasını sağlayacak.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/1*-nUs9Z4piasG5Dw5YPZTew.png" /></figure><h4><strong>3. Dependency Injection ve Mock Kullanımı</strong></h4><p>Uygulamada kullanıcıdan alınan bilgileri ve çıktıyı işlemek için <strong>Dependency Injection (DI)</strong> kullanacağız. Bu, testlerin daha kolay yazılmasını sağlar. Kullanıcı girişini ve çıktısını mock’layarak test ortamı hazırlayacağız.</p><h4><strong>4. Unit Test Yazma</strong></h4><p>Artık, yazdığımız uygulamanın doğru çalışıp çalışmadığını test etmek için <strong>xUnit</strong> test framework’ü ile unit testler yazacağız. İlgili testleri yazarken aşağıdaki noktaları göz önünde bulunduracağız:</p><ul><li>Testlerimiz her bir fonksiyonu bağımsız şekilde test etmeli.</li><li>Testler doğru ve geçerli verilerle yapılmalı.</li><li>Testler hata mesajlarını doğru şekilde kontrol etmeli.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K0usA5ttWTMUfFI5DutSgw.png" /></figure><h3>Test Methodumuzu Açıklayalım :)</h3><p>Yazacağımız Unit Test için genellikle bir adlandırma konvansiyonu kullanılır. Bu test metodunun adı <strong>RegisterUser_ShouldPrintNameInvalid_WhenNameIsTooShort</strong> olarak belirlenmiştir.</p><h4>Bu ismi 3 ana kısmına ayıralım:</h4><ol><li><strong>Test Edilen Metot İsmi:</strong><br><strong>RegisterUser</strong>: Testin, kullanıcı kaydı yapmak için kullanılan RegisterUser metodunu test ettiğini belirtir.</li><li><strong>Beklenen Davranış:</strong><br><strong>Should Print Name Invalid</strong>: Bu kısım, testin beklediği davranışı belirtir. Yani, kullanıcı adı çok kısa olduğunda hata mesajının yazdırılmasını bekliyoruz.</li><li><strong>Testin Şartı (Condition):</strong><br><strong>When Name Is Too Short</strong>: Bu kısım, testin hangi durumda çalıştığını açıklar. Bu test, kullanıcının adı çok kısa olduğunda (örneğin, &quot;A&quot; girildiğinde) hata mesajının doğru şekilde görüntülenip görüntülenmediğini kontrol eder.</li></ol><h4>[Fact] Attribute Nedir?</h4><p>xUnit test çerçevesinde, test metodlarını işaretlemek için <strong>[Fact]</strong> attribute&#39;u kullanılır. Bu attribute, metodun bir test metodu olduğunu belirtir.</p><h4>Mocking Nedir?</h4><p>Mocking, yazılım geliştirmede Unit Testlerde dış bağımlılıkları izole etmek, testlerin güvenilirliğini artırmak ve testleri hızlandırmak amacıyla kullanılan güçlü bir tekniktir. Gerçek nesnelerin yerine, davranışlarını taklit eden mock nesneler kullanarak, testlerinizi odaklanmış ve verimli bir şekilde yapabilirsiniz.</p><p>Mocking, gerçek bağımlılıklar yerine sahte (mock) nesneler kullanarak, test edilen kodun dışarıya olan etkileşimlerini taklit eder. Bu sayede, testlerin dışa bağımlılıklar olmadan daha güvenilir ve odaklanmış bir şekilde yapılması sağlanır.</p><h4>Unit Test 3A Pattern</h4><p>Birim testleri yazarken genellikle <strong>3A Pattern</strong> (Arrange, Act, Assert) adı verilen bir yaklaşım kullanılır. Bu yaklaşım, testin üç temel aşamasını açıklar:</p><h4>1. Arrange (Düzenleme)</h4><p>Testin başında, test senaryosuna uygun bir ortam hazırlanır. Bu aşama, testin izole bir şekilde ve dış etkilerden bağımsız olarak çalışmasını sağlar. Bu aşamada, <strong>mock nesneleri</strong> oluşturulur ve test için gerekli olan tüm bağımlılıklar ayarlanır. Bu, testin belirli bir senaryoya odaklanmasını sağlar.</p><ul><li><strong>Mock Nesnelerinin Hazırlanması:</strong><br>Mock&lt;IUserInput&gt; ve Mock&lt;IUserOutput&gt; nesneleri, kullanıcıdan alınacak bilgilerin ve ekranda gösterilecek çıktının simüle edilmesi için kullanılır.</li><li><strong>SetupSequence:</strong><br>SetupSequence metodu, <strong>GetInput()</strong> metoduna her çağrı yapıldığında farklı veriler döndürmesini sağlar. Bu, kullanıcı sırasıyla isim, soyisim, telefon numarası ve şifre gibi bilgileri girecek şekilde simüle edilir.</li><li><strong>Test Senaryosunun Kurulması:</strong><br>Bu testin amacı, kullanıcı adı <strong>“A”</strong> girildiğinde (çok kısa), ekranda <strong>“Name is invalid.”</strong> mesajının yazdırılıp yazdırılmadığını kontrol etmektir. Bu adımda gerekli veriler mock nesnelerine atanır.</li></ul><h4>2. Act (Uygulama)</h4><p>Testin bu aşamasında, testin amacına uygun gerçek işlem gerçekleştirilir. Bu adımda, <strong>userRegistration.RegisterUser()</strong> metodu çağrılır ve kullanıcı kaydının yapılması sağlanır.</p><ul><li><strong>UserRegister Sınıfı:</strong><br>Burada, <strong>UserRegister</strong> sınıfı mock nesnelerle çalışacak şekilde yapılandırılır. Test edilen metodun gerçek işleyişi, mock nesnelerin simüle ettiği verilerle başlatılır.</li></ul><h4>3. Assert (Doğrulama)</h4><p>Testin son aşamasında, işlemin beklenen şekilde gerçekleşip gerçekleşmediği kontrol edilir. Bu aşamada <strong>_mockUserOutput.Verify()</strong> metodu kullanılarak, doğru hata mesajının yazdırılıp yazdırılmadığı doğrulanır.</p><ul><li><strong>Doğru Çıktı:</strong><br>Verify() metodu ile, <strong>&quot;Name is invalid.&quot;</strong> mesajının doğru şekilde çağrılıp çağrılmadığı kontrol edilir. Eğer bu şart sağlanıyorsa, test başarılı olur.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*0uCBGlRfuRRggUlTRAPBrA.png" /><figcaption>Artık Unit Testimizi çalıştırabiliriz :)</figcaption></figure><h4><strong>5. Code Coverage ve Raporlama</strong></h4><p>Kodun ne kadarını test ettiğimizi görmek için <strong>Code Coverage</strong> raporu oluşturacağız. Bu rapor, testlerin ne kadarını kapsadığını ve hangi bölümlerde eksik kaldığımızı gösterir. <strong>Cobertura</strong> formatında çıktı alarak, <strong>ReportGenerator</strong> ile görsel rapor oluşturacağız.</p><h4>Test Çalıştırma ve Code Coverage Verisi Toplama</h4><p>İlk adımda, yazdığımız testlerin çalıştırılması ve bu testlerin <strong>Code Coverage</strong> (Kod Kapsama) verisinin toplanması gerekmektedir. Bunun için aşağıdaki komutu kullanacağız:</p><pre>dotnet test --results-directory &quot;test-results&quot; --collect:&quot;Code Coverage&quot;</pre><h4>Code Coverage Raporunu Cobertura Formatına Çevirme</h4><p>Testlerin tamamlanmasının ardından, Code Coverage verilerini daha kullanışlı bir formatta raporlamak için <strong>Cobertura formatı</strong> kullanacağız. Cobertura, yaygın olarak kullanılan bir raporlama formatıdır ve birçok araç tarafından desteklenir.</p><p>Aşağıdaki komutu kullanarak bu formatta bir rapor oluşturacağız:</p><pre>dotnet-coverage merge --output test-result.cobertura.xml --output-format cobertura &quot;test-results/**/*.coverage&quot;</pre><h4>Code Coverage Raporunu Görselleştirme</h4><p>Son olarak, Cobertura formatındaki raporu daha görsel bir biçimde incelemek için <strong>ReportGenerator</strong> aracını kullanacağız. Bu araç, raporu HTML formatında oluşturur ve daha kolay bir şekilde incelememizi sağlar.</p><p>Aşağıdaki komutla raporumuzu görsel hale getirebiliriz:</p><pre>reportgenerator -reports:test-result.cobertura.xml -targetdir:coverage-report -reporttypes:&quot;Html_Dark&quot;</pre><p>Bu adımları izleyerek, .NET projenizde yazdığınız testlerin ne kadar kodu kapsadığını görsel olarak inceleyebilirsiniz. Böylece yazılımınızın test kapsamını iyileştirebilir, eksik test alanlarını belirleyebilir ve yazılımın kalitesini artırabilirsiniz. Code Coverage raporları, testlerin etkili ve doğru bir şekilde yazıldığından emin olmanızı sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aQG6SuNtI_1iVyUAwOlDkg.png" /><figcaption>Code Coverage Raporu :)</figcaption></figure><p>Sonuç olarak kodumuzu yazarken ve test ederken, yazılım geliştirme sürecinde karşılaştığımız sorunları öngörebilmek için <strong>Unit Test</strong>’lerin önemi büyüktür. Yazdığımız testler sayesinde, kullanıcıların sistemle etkileşime geçtiği her noktada doğru işlemler yapıldığından emin olabiliriz. Böylece yazılımımızın kalitesini artırır ve daha güvenli bir şekilde geliştirmeye devam edebiliriz.</p><p>Yazılım geliştirme bir süreçtir ve her aşamada dikkatli olmak, yapılan işlerin kalitesini artırmaya yardımcı olur. Unit Test sürecinde öğrendiklerimi sizlere aktardım, umarım sizler için de faydalı olmuştur :)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/564/0*o8yDr_q1haNDCG8Z.jpg" /></figure><h4><strong>Github Repository</strong></h4><p><a href="https://github.com/atakangemici/xUnitCaseStudy">https://github.com/atakangemici/xUnitCaseStudy</a></p><h4>Kaynaklar:</h4><ul><li><a href="https://learn.microsoft.com/en-us/dotnet/core/testing/unit-testing-with-dotnet-test">Unit testing C# code in .NET using dotnet test and xUnit - .NET</a></li><li><a href="https://learn.microsoft.com/tr-tr/shows/visual-studio-toolbox/testing-with-the-xunit-framework-theories-and-assertions-3-of-12-automated-software-testing">xUnit Framework ile test etme - Teoriler ve Onaylar (3 /12)</a></li><li><a href="https://www.meziantou.net/computing-code-coverage-for-a-dotnet-project.htm">Computing code coverage for a .NET project - Gérald Barré</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d1bc7b51f381" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[.Net Core Genel Bakış]]></title>
            <link>https://atakangemici.medium.com/net-core-genel-bak%C4%B1%C5%9F-b4db2d704ad6?source=rss-ba05b059d0b2------2</link>
            <guid isPermaLink="false">https://medium.com/p/b4db2d704ad6</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[net-core]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Atakan Gemici]]></dc:creator>
            <pubDate>Sun, 02 Jan 2022 20:01:21 GMT</pubDate>
            <atom:updated>2025-01-12T15:01:33.889Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CexjRmKSC4e2tptoMN38xQ.png" /><figcaption><strong>.Net Core platformuna genel bakış</strong></figcaption></figure><p>Bugün sizlere bahsedeceğim konu .Net Core platformuna genel bakış olacak. Microsoft ekibi tarafından geliştirilen .Net Core önceki versiyonlardan çok farklı bir yaklaşımla geliştirildi. Geliştirilen bu platformu önceki versiyonlarından ayıran en ayırt edici özelliği Cross-Platform(Platform bağımsız) uygulama geliştirme olanağı sağlayan yapısı oldu.</p><blockquote><strong>.Net Core Cross-Platform Desteği</strong></blockquote><blockquote>Windows</blockquote><blockquote>macOS</blockquote><blockquote>Linux</blockquote><blockquote>.Net Core özellikle son dönemde artış gösteren ve trend mimariler arasında yer alan Micro Service mimarilerinde çok sık tercih edilen bir platform oldu. Micro Service uygulamalarını Containerize etme adımlarında da .Net Core yazılım geliştiricilere büyük kolaylıklar sağlamaktadır. Kubernetes, Dockers ve diğer teknolojilerini destekleyerek bu teknolojilerin kolay bir şekilde uygulamalar içerisinde kullanılabilmesine olanak sağlar. Bu gibi avantajlarının yanı sıra geliştirilen platform açık kaynak kodlu olması sebebiyle de <a href="https://github.com/dotnet/core"><strong>GitHub</strong></a> üzerinde topluluk odaklı bir yaklaşımla kod geliştirilmesine olanak sağladı.</blockquote><h3><strong>.Net Core platformunu toparlayacak olursak ;</strong></h3><p>· Açık kaynak kodlu olması sebebiyle modern bir kod geliştirmeye olanak sağlar.</p><p>· Cross Platform olarak bilinen çapraz geliştirme platformudur.</p><p>· Yeni bir çatı platform olmasına karşın içerisinde başlıca C# programlama dili ile geliştirilmektedir. F# ve Visual Basic ile de geliştirilme yapılabileceği Microsoft .Net Core topluluk web sayfasında belirtiliyor olsa da geliştiricilerin çoğu C# dilini tercih etmektedirler.</p><p>· Container desteği bulunması sebebiyle başlıca Docker ve diğer Container servislerini desteklemektedir.</p><p>· Github için kodların açık bir şekilde yayınlanabilir olmasına olanak sağlar.</p><p>· Modern UI yapılarıyla uyumlu olduğundan Angular, React, Vue, Bootstrap gibi UI yapılar kolaylıkla kullanılabilir ve yönetilebilir.</p><p>· Platform bağımsızlığı sebebiyle sadece IIS web sunucusuna ihtiyaç duymaz IIS, Nginx, Apache , Kestrel gibi sunucularda çalışabilir.</p><p>· Basit Unit Testing desteği sunar.</p><p>· Bağımlılık Enjeksiyon (Dependency Injection) desteği sunar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/760/1*Pdv_Ok4ERui-ioJ7e1v05g.jpeg" /></figure><p>Projenizi .Net Core platformunda geliştirmeye karar verdiğinizde .Net Core projesinin çok soft bir şekilde bilgisayar ortamınıza kurulduğunu ve aslında önceki .Net versiyonlarından çok farklı bir şekilde olduğunu göreceksiniz. .Net Core adından da anlaşılacağı gibi size Core bir yapı sunar gereksiz şeyleri ilk kurulumda projenize dahil etmez , siz ihtiyaçlarınız doğrultusunda kullanacağınız bileşenleri projenize dahil edersiniz ve kullanmaya başlarsınız.</p><p><em>Yeni yazılarda görüşmek dileğiyle :)</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b4db2d704ad6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Full Stack Development]]></title>
            <link>https://atakangemici.medium.com/full-stack-development-96d07cbc9b16?source=rss-ba05b059d0b2------2</link>
            <guid isPermaLink="false">https://medium.com/p/96d07cbc9b16</guid>
            <category><![CDATA[net-core]]></category>
            <category><![CDATA[roadmap-software]]></category>
            <category><![CDATA[full-stack-development]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Atakan Gemici]]></dc:creator>
            <pubDate>Sat, 11 Dec 2021 18:39:17 GMT</pubDate>
            <atom:updated>2025-01-12T15:02:46.601Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T6L2FG_vMBpVCxA_4m2J3A.jpeg" /><figcaption><strong>Nedir bu Full Stack Developer ?</strong></figcaption></figure><p>Full Stack Developer hakkında bilinmesi gerekenlerden ve sektör de nasıl konumlandırıldığından bahsetmek istiyorum.</p><blockquote>Şimdiden keyifli okumalar diliyorum :)</blockquote><p>Full Stack Developer aslında ülkemizde çok sevilen developer rollerinden. Çok sevilmesindeki en büyük etken size verilen bir iş’in tüm geliştirme süreçlerini uçtan uca tek başınıza yapabilmeniz diyebiliriz.Kulağa hoş gelen bu durumun bu rolü üstlenen geliştiriciler için çokça zorlukları da var.</p><p>Bana göre en büyük zorluklarından biri işiniz de uzmanlaşma konusu.Full Stack geliştirici olduğunuz da aslında odak noktanız dağılıyor.Bu da uzmanlaşma konusunda size ekstra zorluk olarak dönüyor.Bu durum benim de en çok zorluğunu yaşadığım konuların başında geliyor.Bu durumun üstesinden gelmek için ekstra çaba göstererek iki yönlü araştırmalar ile kendinizi güncel tutmak adına daha fazla uğraşmanız gerekiyor.</p><p>Bu rolün zorlukları yanında çokça avantajları da bulunuyor.Kendimden örnek vermem gerekirse ben yeni uygulamalar çıkarmayı ve bunları yayınlamayı çok seviyorum , aklıma bir fikir geldiğinde bunun kodlamasını yapmak için can atıyorum diyebilirim.İşte bura da Full Stack Developer olmanın avantajını yaşıyorum. Çünkü aklıma gelen fikri hayata geçirmek için sadece kendime ihtiyaç duyuyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*qveqq4_nSAd6WEVnmWmHnA.jpeg" /><figcaption>Full Stack Developer’ın özeti :)</figcaption></figure><p>Bir başka artısından bahsetmek gerekirse iş bulma alanındaki imkanlar.İki taraflı geliştirici olduğunuzda karşınıza çıkan fırsatta hangi tarafta developer arandığının bir önemi sizin için kalmıyor.Çünkü Full Stack Developer aslında hem Backend Developer hem de FrontEnd developer’dır.Bu durum sayesinde bir alana bağımlı kalmadan yolunuza istediğiniz şekilde yön verebiliyorsunuz.</p><p><em>Yeni yazılarda görüşmek dileğiyle :)</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96d07cbc9b16" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>