<?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 Oğulcan Dinsever on Medium]]></title>
        <description><![CDATA[Stories by Oğulcan Dinsever on Medium]]></description>
        <link>https://medium.com/@ogulcandnsvr?source=rss-51260da3990d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*TeajLwTNybW69h-t</url>
            <title>Stories by Oğulcan Dinsever on Medium</title>
            <link>https://medium.com/@ogulcandnsvr?source=rss-51260da3990d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 05:19:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ogulcandnsvr/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 HybridCache: Aynı Veriye Gelen 100 İstek Nasıl Yönetilir?]]></title>
            <link>https://medium.com/@ogulcandnsvr/net-hybridcache-ayn%C4%B1-veriye-gelen-100-i%CC%87stek-nas%C4%B1l-y%C3%B6netilir-17205b021a05?source=rss-51260da3990d------2</link>
            <guid isPermaLink="false">https://medium.com/p/17205b021a05</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[caching]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <dc:creator><![CDATA[Oğulcan Dinsever]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 09:44:58 GMT</pubDate>
            <atom:updated>2026-10-20T09:44:58.337Z</atom:updated>
            <content:encoded><![CDATA[<p>Merhaba, bu yazıda .NET HybridCache’i aynı veriye eşzamanlı gelen istekler üzerinden incelemek istiyorum. Cache eklediğimizde veritabanına daha az gideceğimizi düşünüyoruz. Peki cache henüz boşken 100 istek aynı anda gelirse ne oluyor? Küçük bir örnekle bakalım. İyi okumalar :)</p><p><em>Hazırlık notu: Bu yazının metni ve kapak görseli yapay zekâ desteğiyle hazırlanmıştır. Kod örnekleri .NET 10 üzerinde çalıştırılmış, grafik bu yazı için yapılan denemenin sonuçlarından üretilmiştir.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*US6qjHHVSgeTHH3fYjr04w.png" /><figcaption>Yapay zekâ ile üretilmiş kavramsal kapak. Birleşen çizgiler, aynı veriyi isteyen çağrıların ortak sonucu beklemesini temsil ediyor.</figcaption></figure><h3>Önce problemi görelim: Cache stampede</h3><p>Bir ürün detayını cache’lediğimizi düşünelim. Kayıt cache’te dururken işler kolay: Gelen istekler hazır veriyi alıyor. Asıl soru, bu kaydın süresi dolduğu anda başlıyor.</p><p>İlk istek cache’i boş buluyor ve veriyi kaynaktan getirmeye başlıyor. İşlem tamamlanmadan ikinci, üçüncü ve diğer istekler de geliyor. Onlar da cache’i boş görüyor. Sonuçta aynı ürün için aynı iş tekrar tekrar yapılabiliyor. Bu duruma <strong>cache stampede</strong> deniyor. Microsoft’un <a href="https://devblogs.microsoft.com/dotnet/hybrid-cache-is-now-ga/">HybridCache duyurusu</a> da bu problemi örnekliyor.</p><p>Örneğin şu kod, tek başına eşzamanlı factory çağrılarını birleştirmiyor:</p><pre>await memoryCache.GetOrCreateAsync(&quot;product:v1:42&quot;, async entry =&gt;<br>{<br>    entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5);<br>    return await LoadProductAsync(42);<br>});</pre><p>Burada cache’in eşzamanlı kullanıma uygun olmasıyla, veriyi üreten fonksiyonun yalnızca bir kez çalışması farklı konular. <a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/memory?view=aspnetcore-10.0#additional-notes">IMemoryCache dokümanı</a>, cache yeniden doldurulurken birden fazla isteğin aynı işi başlatabileceğini açıkça belirtiyor. Benim burada kontrol etmek istediğim davranış tam olarak bu.</p><h3>HybridCache bu akışı nasıl değiştiriyor?</h3><p>HybridCache, bellek içi önbelleği ve isteğe bağlı dağıtık önbelleği aynı API altında kullanmamızı sağlıyor. <strong>L1</strong>, uygulamanın kendi belleği; <strong>L2</strong> ise yapılandırırsak Redis gibi ortak bir önbellek. Bu iki katmanın rolünü <a href="https://devblogs.microsoft.com/dotnet/hybrid-cache-is-now-ga/">resmî duyuruda</a> da görebilirsiniz.</p><p>Okuma sırası L1 → varsa L2 → veri kaynağı şeklinde ilerliyor. Veri bir cache katmanında bulunursa factory’ye gerek kalmıyor. İki katmanda da bulunamazsa aynı key için gelen eşzamanlı çağrılar, aynı HybridCache instance’ında ortak factory sonucunu bekliyor. Bu davranışın kapsamı <a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/hybrid?view=aspnetcore-10.0#get-and-store-cache-entries">güncel dokümanda</a> özellikle açıklanıyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*evW3KT7mxc1b1tljEFKmdQ.png" /><figcaption>Her uygulamanın kendi L1’i var. L2 paylaşılabilir; çağrı birleştirme HybridCache instance’ı içinde gerçekleşir. L2 yoksa doğrudan kaynağa gidilir.</figcaption></figure><h3>Küçük bir Minimal API örneği</h3><p>Örneği .NET 10 üzerinde hazırladım. Önce projeyi ve paketi ekleyelim:</p><pre>dotnet new web -n HybridCacheApi<br>cd HybridCacheApi<br>dotnet add package Microsoft.Extensions.Caching.Hybrid --version 10.11.0</pre><p>Burada kullandığım <a href="https://www.nuget.org/packages/Microsoft.Extensions.Caching.Hybrid/10.11.0">10.11.0 sürümünü</a> sabitliyorum; böylece örnek aynı paketle tekrar çalıştırılabilir. Program.cs dosyası şöyle:</p><pre>using Microsoft.Extensions.Caching.Hybrid;<br>var builder = WebApplication.CreateBuilder(args);<br>builder.Services.AddHybridCache(options =&gt;<br>{<br>    options.DefaultEntryOptions = new HybridCacheEntryOptions<br>    {<br>        Expiration = TimeSpan.FromMinutes(5),<br>        LocalCacheExpiration = TimeSpan.FromSeconds(30)<br>    };<br>});<br>var app = builder.Build();<br>app.MapGet(&quot;/products/{id:int}&quot;, async (<br>    int id, HybridCache cache, CancellationToken cancellationToken) =&gt;<br>{<br>    var product = await cache.GetOrCreateAsync(<br>        $&quot;product:v1:{id}&quot;,<br>        async token =&gt;<br>        {<br>            await Task.Delay(200, token);<br>            return new Product(id, &quot;Örnek ürün&quot;);<br>        },<br>        cancellationToken: cancellationToken);<br>    return Results.Ok(product);<br>});<br>app.Run();<br>sealed record Product(int Id, string Name);</pre><p>Task.Delay burada veritabanını temsil eden bir bekleme. Gerçek uygulamada bu satırların yerine repository veya HTTP çağrısı gelecek. Factory’nin aldığı token’ı bu işleme geçiriyorum. Aynı ürünün anahtarı sabit; farklı ürünler farklı anahtarlarla saklanıyor.</p><p>Bu ilk örnekte Redis yok; bellek içi cache ve çağrı birleştirmeyi incelemek için yeterli. Seçtiğim 30 saniye ve 5 dakika değerleri birer örnek. LocalCacheExpiration yerel katmanın süresini, Expiration genel saklama süresini belirliyor. Ayarların açıklaması <a href="https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.caching.hybrid.hybridcacheentryoptions">HybridCacheEntryOptions API’sinde</a> bulunuyor. L2 yapılandırılmadığı için bu örnek 5 dakikalık ortak bir Redis kaydı oluşturmuyor.</p><h3>100 eşzamanlı istekte kaç kaynak çağrısı oluştu?</h3><p>Davranışı görmek için ayrıca küçük bir konsol denemesi hazırladım. Aynı process içinde aynı key’e 1, 10, 50 ve 100 eşzamanlı çağrı gönderdim. Her senaryoda temiz bir cache ile başladım ve denemeyi üç kez tekrarladım.</p><p>Kaynak fonksiyonu bir sayaç artırıyor ve en az 200 ms bekliyor. Başlangıç kapısı çağrıları aynı grupta serbest bırakıyor; ayrıca tüm çağrılar cache API’sine girene kadar kaynak sonucunun dönmesini bekletiyorum. Böylece cache dolmadan gelen çağrıların örtüşmesini kontrollü olarak sağlıyorum. Her grubun ardından cache doluyken aynı sayıda çağrıyı yeniden çalıştırdım. Bu bir HTTP yük testi veya veritabanı performans testi değil; ölçtüğüm şey <strong>kaynak fonksiyonunun kaç kez çağrıldığı</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KcTHPGne1Rp9DLsK5VF-vw.png" /><figcaption>Kontrollü örtüşme deneyi: tek process ve aynı key. Üç tekrarda soğuk cache kaynak çağrıları IMemoryCache için 1/10/50/100, HybridCache için her grupta 1. Sıcak cache’te iki yöntemde de 0 yeni kaynak çağrısı.</figcaption></figure><p>100 çağrılık grupta kaynak fonksiyonunun 100 yerine 1 kez çalışması, gereksiz tekrarın önlendiğini gösteriyor. Bu sayıdan bir yanıt süresi oranı çıkaramam. Gerçek sistemde sorgu maliyeti, ağ, veri boyutu ve eşzamanlı farklı anahtarlar sonucu değiştirecek. Bu yüzden grafiği okurken dikey eksenin “milisaniye” değil, “çağrı sayısı” olduğuna dikkat etmek gerekiyor.</p><h3>Redis eklersem ne değişir?</h3><p>Birden fazla uygulama instance’ının ortak cache kullanmasını istiyorsak L2 ekleyebiliriz. Bunun için Microsoft.Extensions.Caching.StackExchangeRedis paketini kurup, builder.Build() öncesinde şu kaydı yapabiliriz:</p><pre>builder.Services.AddStackExchangeRedisCache(options =&gt;<br>{<br>    options.Configuration = builder.Configuration<br>        .GetConnectionString(&quot;Redis&quot;)<br>        ?? throw new InvalidOperationException(&quot;Redis bağlantısı eksik.&quot;);<br>});</pre><p>Bağlantı bilgisini uygulama konfigürasyonunda tutuyorum. Bu bölüm yapılandırma örneği; yukarıdaki denemede Redis çalıştırılmadı. L2 kurulumunun ayrıntıları <a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/hybrid?view=aspnetcore-10.0#serialization">Microsoft Learn’da</a> yer alıyor.</p><h3>Projeye eklerken dikkat edeceğim üç nokta</h3><p><strong>1. Sunucular arasında tek factory garantisi beklemem.</strong> Aynı Redis’i kullansalar bile farklı HybridCache instance’ları kendi kaynak çağrılarını başlatabilir. Bu kütüphane, bütün sunucuları kapsayan dağıtık kilit sağlamıyor. Tek process’teki grafiği çok sunuculu sisteme doğrudan genellememek gerekiyor. <a href="https://github.com/dotnet/extensions/blob/main/src/Libraries/Microsoft.Extensions.Caching.Hybrid/Internal/DefaultHybridCache.Stampede.cs#L13-L31">İstek birleştirmenin kaynak kodu</a> da instance içindeki koordinasyonu gösteriyor.</p><p><strong>2. Güncelleme akışını ayrıca tasarlarım.</strong> Ürün güncellendiğinde ilgili key’i RemoveAsync ile geçersizleştirebilirim. Ancak mevcut sunucu ve L2 üzerinde yapılan geçersizleştirme, diğer sunucuların L1 kayıtlarını anında temizlemiyor. Bu nedenle yerel süreyi, kabul edebileceğim eski veri penceresine göre seçerim. RemoveAsync’nin yerel cache’i ve arka ucu temizlediği, <a href="https://github.com/dotnet/extensions/blob/main/src/Libraries/Microsoft.Extensions.Caching.Hybrid/Internal/DefaultHybridCache.cs#L185-L189">resmî kaynak kodunda</a> da görülebiliyor.</p><p><strong>3. Key’i veri sözleşmesinin parçası olarak görürüm.</strong> Örnekteki product:v1:42 küçük bir başlangıç. Ürün bilgisi tenant’a veya dile göre değişiyorsa bunları da anahtara eklemem gerekir. Aynı key altında farklı kullanıcılara ait sonuçların karışmasını istemem. Cache’in kapsamını önce verinin kapsamıyla eşleştiririm.</p><h3>Benim için nerede anlamlı?</h3><p>Bir projede aynı verinin sık okunduğunu ve cache boşaldığında aynı kaynak işinin tekrarlandığını görüyorsam HybridCache’i değerlendirmek isterim. Kendi senaryomda da önce bu yazıdaki gibi küçük bir deneme kurar, sonra gerçek veri kaynağıyla ölçerim.</p><p>Bu örnekte en faydalı bulduğum taraf, cache boşken gelen isteklerin davranışını görünür kılması oldu. Cache eklerken bundan sonra ilk bakacağım sorulardan biri şu: “Veri henüz hazır değilken aynı key’i isteyen diğer çağrılar ne yapıyor?”</p><p>Umarım faydalı olmuştur. Siz projelerinizde IMemoryCache, Redis veya HybridCache kullanıyor musunuz? Özellikle çok sunuculu uygulamalarda invalidation tarafını nasıl çözdüğünüzü yorumlarda okumak isterim. Okuduğunuz için teşekkürler :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17205b021a05" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Modern .NET Mimarisi: 2025'te Senior Developer'ların Benimsediği Pattern'lar]]></title>
            <link>https://medium.com/@ogulcandnsvr/modern-net-mimarisi-2025te-senior-developer-lar%C4%B1n-benimsedi%C4%9Fi-pattern-lar-3ebfb595319a?source=rss-51260da3990d------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ebfb595319a</guid>
            <dc:creator><![CDATA[Oğulcan Dinsever]]></dc:creator>
            <pubDate>Tue, 23 Jun 2026 08:11:53 GMT</pubDate>
            <atom:updated>2026-06-23T10:58:34.991Z</atom:updated>
            <content:encoded><![CDATA[<h3>Giriş</h3><p>Her .NET projesi bir şekilde Clean Architecture ile başlar. Katmanlar oluşturulur, interface’ler yazılır, repository’ler sıralanır — ve birkaç sprint sonra herkes “neden bu kadar karmaşık?” diye sorar.</p><p>Bu makale, 2025 itibarıyla .NET ekosisteminde battle-tested hale gelmiş <strong>beş temel pattern</strong>’ı ele alıyor: nasıl çalıştıklarını, neden önemli olduklarını ve gerçek kodda nasıl göründüklerini.</p><h3>1. Vertical Slice Architecture</h3><p>Clean Architecture’da bir feature eklerken çoğunlukla <strong>7–10 farklı katmana</strong> dokunursunuz. Controller, service interface, service implementation, repository, DTO, mapper, validator…</p><p>Vertical Slice bunun tam tersi: <em>katmanlara göre değil, feature’lara göre organize et.</em> Her dilim kendi içinde bağımsızdır. Temel fikir: <strong>birlikte değişen kod, birlikte durmalıdır.</strong></p><p>Klasör yapısı şu şekilde görünür:</p><pre>src/<br>├── Features/<br>│   ├── Users/<br>│   │   ├── CreateUser/<br>│   │   │   ├── CreateUserCommand.cs<br>│   │   │   ├── CreateUserHandler.cs<br>│   │   │   ├── CreateUserValidator.cs<br>│   │   │   └── CreateUserResponse.cs<br>│   │   ├── UpdateUser/<br>│   │   └── DeleteUser/<br>│   └── Orders/<br>└── Common/</pre><p>Handler ve Minimal API endpoint aynı dosyada veya yakın tutulur, ayrı controller yazılmaz:</p><pre>public record CreateUserCommand(string Email, string Name) : IRequest&lt;CreateUserResponse&gt;;</pre><pre>public class CreateUserHandler : IRequestHandler&lt;CreateUserCommand, CreateUserResponse&gt;<br>{<br>    private readonly AppDbContext _db;<br>    public CreateUserHandler(AppDbContext db) =&gt; _db = db;</pre><pre>    public async Task&lt;CreateUserResponse&gt; Handle(<br>        CreateUserCommand request, CancellationToken ct)<br>    {<br>        var user = new User<br>        {<br>            Id = UserId.NewId(),<br>            Email = request.Email,<br>            Name = request.Name,<br>            CreatedAt = DateTime.UtcNow<br>        };<br>        _db.Users.Add(user);<br>        await _db.SaveChangesAsync(ct);<br>        return new CreateUserResponse(user.Id, user.Email);<br>    }<br>}</pre><pre>app.MapPost(&quot;/users&quot;, async (CreateUserCommand cmd, ISender sender) =&gt;<br>{<br>    var result = await sender.Send(cmd);<br>    return Results.Created($&quot;/users/{result.Id}&quot;, result);<br>}).WithName(&quot;CreateUser&quot;).WithOpenApi();</pre><p><strong>Ne zaman kullanmalı?</strong> Orta-büyük projelerde, feature’lar bağımsız gelişiyorsa idealdir. Küçük CRUD API’larda overhead yaratabilir.</p><h3>2. Result Pattern</h3><p>Exception’lar kontrolsüz bir uçuştur. throw new NotFoundException() yazdığınızda çağrı zincirinin herhangi bir noktasında yakalanabilir — ya da hiç yakalanmayabilir. Bu belirsizlik büyük projelerde <strong>sessiz hata kayıplarına</strong> yol açar.</p><p>Result Pattern, bir operasyonun başarı ya da hata ile sonuçlandığını açıkça modelleyen bir yaklaşımdır. FluentResults kütüphanesi kullanılabileceği gibi sıfırdan minimal bir implementasyon da yeterlidir:</p><pre>public class Result&lt;T&gt;<br>{<br>    public bool IsSuccess { get; }<br>    public T? Value { get; }<br>    public Error? Error { get; }</pre><pre>    private Result(T value)     { IsSuccess = true;  Value = value; }<br>    private Result(Error error) { IsSuccess = false; Error = error; }</pre><pre>    public static Result&lt;T&gt; Ok(T value)     =&gt; new(value);<br>    public static Result&lt;T&gt; Fail(Error err) =&gt; new(err);<br>}</pre><pre>public record Error(string Code, string Message)<br>{<br>    public static readonly Error NotFound     = new(&quot;NOT_FOUND&quot;,     &quot;Kaynak bulunamadı.&quot;);<br>    public static readonly Error Unauthorized = new(&quot;UNAUTHORIZED&quot;,  &quot;Yetkiniz bulunmuyor.&quot;);<br>}</pre><pre>// Handler — exception atmak yerine Result döndür<br>public async Task&lt;Result&lt;UserDto&gt;&gt; Handle(GetUserQuery query, CancellationToken ct)<br>{<br>    var user = await _db.Users.FindAsync([query.Id], ct);<br>    if (user is null) return Result&lt;UserDto&gt;.Fail(Error.NotFound);<br>    return Result&lt;UserDto&gt;.Ok(user.ToDto());<br>}</pre><pre>// Minimal API — Result&#39;ı HTTP response&#39;a çevir<br>app.MapGet(&quot;/users/{id}&quot;, async (Guid id, ISender sender) =&gt;<br>{<br>    var result = await sender.Send(new GetUserQuery(id));<br>    return result.IsSuccess<br>        ? Results.Ok(result.Value)<br>        : result.Error!.Code switch<br>        {<br>            &quot;NOT_FOUND&quot;    =&gt; Results.NotFound(),<br>            &quot;UNAUTHORIZED&quot; =&gt; Results.Unauthorized(),<br>            _              =&gt; Results.Problem(result.Error!.Message)<br>        };<br>});</pre><p><strong>Önemli not:</strong> Her şeyi Result’a sarmak gerekmez. Gerçek istisnai durumlar (DB bağlantısı kopması, disk dolu) için exception doğru araçtır. Result Pattern <em>beklenen iş mantığı hatalarını</em> modellemek içindir.</p><h3>3. Strongly Typed IDs</h3><p><strong>Primitive Obsession</strong> — .NET projelerinde en yaygın kod kokusudur. Her entity’nin ID’si Guid olarak dolaşır ve compiler hiçbir zaman sizi uyarmaz:</p><pre>// Compiler bunu kabul eder — ama çok yanlış!<br>void AssignUserToOrder(Guid userId, Guid orderId) { ... }</pre><pre>Guid userId  = user.Id;<br>Guid orderId = order.Id;<br>AssignUserToOrder(orderId, userId); // BUG — parametreler ters, compiler sessiz</pre><p>C# 12 primary constructor ve implicit operator ile tip güvenli ID’ler yazmak artık çok temiz:</p><pre>public readonly record struct UserId(Guid Value)<br>{<br>    public static UserId NewId() =&gt; new(Guid.NewGuid());<br>    public static implicit operator Guid(UserId id) =&gt; id.Value;<br>    public static implicit operator UserId(Guid g)  =&gt; new(g);<br>    public override string ToString() =&gt; Value.ToString();<br>}</pre><pre>public readonly record struct OrderId(Guid Value)<br>{<br>    public static OrderId NewId() =&gt; new(Guid.NewGuid());<br>    public static implicit operator Guid(OrderId id) =&gt; id.Value;<br>    public static implicit operator OrderId(Guid g)  =&gt; new(g);<br>}</pre><pre>// Artık tip güvenli — compiler yanlış kullanımı yakalar<br>void AssignUserToOrder(UserId userId, OrderId orderId) { ... }</pre><pre>AssignUserToOrder(orderId, userId);<br>// CS1503: cannot convert &#39;OrderId&#39; to &#39;UserId&#39;</pre><p>EF Core’da Value Converter ile sorunsuz çalışır:</p><pre>builder.Entity&lt;User&gt;()<br>    .Property(u =&gt; u.Id)<br>    .HasConversion(<br>        id  =&gt; id.Value,<br>        raw =&gt; new UserId(raw)<br>    );</pre><h3>4. Modular Monolith</h3><p>Microservice mimarisi güçlü bir araçtır — ama çoğu takım için <em>erken bir araçtır.</em> Ayrı deployment pipeline’ları, distributed tracing, network hataları, eventual consistency… Bunların hepsi gerçek maliyetlerdir.</p><p>Modular Monolith bu iki uç arasında pratik bir köprü kurar: tek process içinde çalışır (deployment kolaylığı), ancak modüller arası sınırlar keskin tutulur (mimari temizlik).</p><pre>public static class UsersModule<br>{<br>    public static IServiceCollection AddUsersModule(<br>        this IServiceCollection services, IConfiguration config)<br>    {<br>        services.AddDbContext&lt;UsersDbContext&gt;(opt =&gt;<br>            opt.UseSqlServer(config.GetConnectionString(&quot;Users&quot;)));<br>        services.AddScoped&lt;IUserModule, UserModuleService&gt;();<br>        services.AddMediatR(cfg =&gt;<br>            cfg.RegisterServicesFromAssemblyContaining&lt;UsersModule&gt;());<br>        return services;<br>    }</pre><pre>    public static IEndpointRouteBuilder MapUsersModule(<br>        this IEndpointRouteBuilder app)<br>    {<br>        var group = app.MapGroup(&quot;/api/users&quot;).WithTags(&quot;Users&quot;);<br>        group.MapPost(&quot;/&quot;, CreateUserHandler.Handle);<br>        group.MapGet(&quot;/{id}&quot;, GetUserHandler.Handle);<br>        return app;<br>    }<br>}</pre><pre>// Program.cs<br>builder.Services<br>    .AddUsersModule(builder.Configuration)<br>    .AddOrdersModule(builder.Configuration)<br>    .AddNotificationsModule(builder.Configuration);</pre><pre>app.MapUsersModule()<br>   .MapOrdersModule()<br>   .MapNotificationsModule();</pre><p><strong>Altın kural:</strong> Modüller birbirinin DbContext’ine hiçbir zaman doğrudan erişmemelidir. Modüller arası iletişim yalnızca interface veya domain event üzerinden olmalıdır. Bu sınır bozulursa Modular Monolith’in tüm değeri yok olur.</p><h3>5. HybridCache (.NET 9)</h3><p>.NET projelerinde cache genellikle iki katmanda kurulur: IMemoryCache (L1, in-process) ve Redis (L2, distributed). İkisini ayrı yönetmek; farklı API’lar, tutarsız expiration politikaları anlamına gelir.</p><p>.NET 9 ile gelen <strong>HybridCache</strong> bu iki katmanı tek soyutlama altında birleştirir: önce L1&#39;e bakar, yoksa L2&#39;ye, yoksa kaynağa gider ve her ikisini günceller.</p><pre>builder.Services.AddHybridCache(opt =&gt;<br>{<br>    opt.MaximumPayloadBytes = 1024 * 1024;<br>    opt.DefaultEntryOptions = new HybridCacheEntryOptions<br>    {<br>        Expiration          = TimeSpan.FromMinutes(5),<br>        LocalCacheExpiration = TimeSpan.FromMinutes(1)<br>    };<br>});</pre><pre>// Redis L2 (isteğe bağlı)<br>builder.Services.AddStackExchangeRedisCache(opt =&gt;<br>    opt.Configuration = builder.Configuration.GetConnectionString(&quot;Redis&quot;));</pre><pre>public class ProductService(HybridCache cache, AppDbContext db)<br>{<br>    public async ValueTask&lt;ProductDto?&gt; GetAsync(ProductId id, CancellationToken ct = default)<br>    {<br>        return await cache.GetOrCreateAsync(<br>            key: $&quot;product:{id}&quot;,<br>            factory: async token =&gt;<br>            {<br>                var p = await db.Products.FindAsync([(Guid)id], token);<br>                return p?.ToDto();<br>            },<br>            options: new HybridCacheEntryOptions { Expiration = TimeSpan.FromHours(1) },<br>            cancellationToken: ct);<br>    }</pre><pre>    public async Task InvalidateAsync(ProductId id, CancellationToken ct) =&gt;<br>        await cache.RemoveAsync($&quot;product:{id}&quot;, ct);<br>}</pre><p><strong>Cache Stampede koruması:</strong> Aynı key için 50 eşzamanlı istek geldiğinde HybridCache factory’yi yalnızca bir kez çalıştırır ve diğerlerini bekletir — built-in, ekstra kod gerekmez.</p><h3>Sonuç: Hangi Pattern’ı Ne Zaman?</h3><p>Bu beş pattern birbirini tamamlar, çelişmez. Çoğu orta-büyük .NET projesinde hepsini bir arada kullanmak mümkündür:</p><ul><li><strong>Vertical Slice</strong> — Feature’lar bağımsız gelişiyorsa ve ekip feature ownership’e göre bölünmüşse</li><li><strong>Result Pattern</strong> — Domain hatalarını (NotFound, Conflict) açıkça modellemek istiyorsanız</li><li><strong>Strongly Typed IDs</strong> — Primitive obsession varsa — hemen hemen her projede kullanın</li><li><strong>Modular Monolith</strong> — Microservice’e hazır değilseniz ama domain sınırları netleştiyse</li><li><strong>HybridCache</strong> — .NET 9+ projelerinde memory ve distributed cache ikisini kullanıyorsanız</li></ul><p>Yazılım mimarisi seçimler toplamıdır — kurallar değil. <strong>En iyi mimari, projenizin bugünkü ve yakın gelecekteki ihtiyaçlarına uyan mimaridir.</strong></p><p>.NET · CSharp · Software Architecture · Programming · Web Development</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ebfb595319a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Identity API endpoints]]></title>
            <link>https://medium.com/@ogulcandnsvr/identity-api-endpoints-6923702f594c?source=rss-51260da3990d------2</link>
            <guid isPermaLink="false">https://medium.com/p/6923702f594c</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Oğulcan Dinsever]]></dc:creator>
            <pubDate>Wed, 05 Jun 2024 20:06:01 GMT</pubDate>
            <atom:updated>2024-06-05T21:14:04.426Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Merhaba bu yazida .NET 8`in ASP.NET Core Identity icin yaptigi iyilestirmelerden bahsedecegim. Iyi okumalar :)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*6RQx0JFudF_SJP-K.png" /></figure><p>.NET 8, ASP.NET Core Identity için önemli iyileştirmeler getirdi. Yeni eklenen “Identity API endpoints” sayesinde kimlik doğrulama işlemleri (kayıt, giriş, şifre yönetimi vb.) minimal API’lerle gerçekleştirilebiliyor. Bu endpoint’ler EF Core ve minimal DI konfigürasyonu ile kolayca ayarlanabilir. Varsayılan olarak JWT kullanılmıyor, bu yüzden token tabanlı kimlik doğrulama için ek konfigürasyon gerekebilir. Ancak, şu an için bu endpoint’ler özelleştirilemiyor. Genel olarak, kimlik doğrulama sürecini sadeleştirip, kullanıcı yönetiminde daha esnek bir yaklaşım sunuyorlar.</p><h4>Oncelikle Identity API endpoints nedir ona bakalim.</h4><p>Identity API endpoints, ASP.NET Core Identity içinde kullanıcı kayıt, giriş, şifre yönetimi gibi temel kimlik doğrulama işlemlerini minimal API’ler aracılığıyla gerçekleştirmeyi sağlar. Bu API’ler, daha az yapılandırma ile kimlik doğrulama işlevlerini uygulamak isteyen geliştiriciler için tasarlanmıştır.</p><p><strong>Biraz daha detayli inceleyelim</strong></p><p>Yeni kimlik doğrulama yöntemlerini kullanmanın kolay bir yolu, bunları temel bir Web API uygulamasında etkinleştirmektir. Aynı uygulama, Blazor WebAssembly, Angular, React ve diğer Tek Sayfa Web uygulamaları (SPA) için backend olarak da kullanılabilir. .NET 8&#39;de OpenAPI içeren bir ASP.NET Core Web API projesi ile başladığınızı varsayarak, kimlik doğrulamayı birkaç adımda ekleyebilirsiniz.</p><p>Kimlik doğrulama “isteğe bağlı” olduğundan, eklemeniz gereken bazı paketler vardır:</p><ul><li>Microsoft.AspNetCore.Identity.EntityFrameworkCore: EF Core entegrasyonunu sağlayan paket</li><li>Kullanmak istediğiniz veritabanı için bir paket, örneğin Microsoft.EntityFrameworkCore.SqlServer (bu örnekte in-memory veritabanını kullanacağız)</li></ul><p>Bu paketleri NuGet paket yöneticisi veya komut satırı kullanarak ekleyebilirsiniz. Örneğin, komut satırını kullanarak paketleri eklemek için proje klasörüne gidin ve aşağıdaki dotnet komutlarını çalıştırın:</p><blockquote>-dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore<br>-dotnet add package Microsoft.EntityFrameworkCore.InMemory</blockquote><h3>Kimlik Doğrulama ve Yetkilendirme Ayarları</h3><p>Projenizde kimlik doğrulama ve yetkilendirmeyi ayarlamak için aşağıdaki adımları izleyin:</p><h4>1. EF Core ve Identity Ayarları</h4><p>Program.cs dosyanızda, EF Core ve Identity Core&#39;u aşağıdaki gibi ayarlayın:</p><pre>builder.Services.AddDbContext&lt;AppDbContext&gt;(options =&gt;<br> options.UseInMemoryDatabase(“InMemoryDb”));</pre><pre>builder.Services.AddIdentityCore&lt;ApplicationUser&gt;()<br> .AddEntityFrameworkStores&lt;AppDbContext&gt;();</pre><pre>builder.Services.AddAuthentication()<br> .AddBearerToken(IdentityConstants.BearerScheme);</pre><pre>builder.Services.AddAuthorization();</pre><h4>2. Identity API Endpoint’lerini Haritalama</h4><p>Uygulamanızın yapılandırmasında Identity API endpoint’lerini haritalayın:</p><pre>var app = builder.Build();</pre><pre>app.MapIdentityApi&lt;ApplicationUser&gt;();</pre><pre>app.Run();</pre><h3>Kullanıcı Kayıt ve Giriş İşlemleri</h3><p>Identity API endpoint’leri ile kullanıcı kayıt ve giriş işlemleri oldukça basittir. Aşağıda, kullanıcı kayıt ve giriş işlemleri için örnek istekler verilmiştir:</p><p><em>Kullanici kaydi:</em></p><pre>POST /register<br>Content-Type: application/json</pre><pre>{<br> “username”: “newuser”,<br> “password”: “Password123!”,<br> “email”: “newuser@example.com”<br>}</pre><p><em>Kullanıcı Girişi</em></p><pre>POST /login<br>Content-Type: application/json</pre><pre>{<br> “username”: “newuser”,<br> “password”: “Password123!”<br>}</pre><p>Umarim faydali olmustur. Okudugunuz icin tesekkurler. Alkis atmayi unutmayin :))</p><p><em>Kaynak: </em><a href="https://devblogs.microsoft.com/dotnet/whats-new-with-identity-in-dotnet-8/"><em>https://devblogs.microsoft.com/dotnet/whats-new-with-identity-in-dotnet-8/</em></a></p><p><em>GitHub: </em><a href="https://github.com/Ogulcan-Dinsever"><em>https://github.com/Ogulcan-Dinsever</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6923702f594c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>