ASP.NET Core .NET 10

Program.cs Rehberi: Yapılandırabileceğiniz Her Şey

ASP.NET Core .NET 10 Program.cs Rehberi: Yapılandırabileceğiniz Her Şey

Modern ASP.NET Core uygulamalarında (.NET 6 ve sonrası, özellikle .NET 10 ile birlikte) Program.cs, uygulamanın merkezi başlangıç noktasıdır.

Eskiden kullanılan Startup.cs yapısı artık opsiyoneldir. Günümüzde çoğu ASP.NET Core uygulaması Minimal Hosting Model kullanır.

Program.cs dosyası üzerinden:

• Dependency Injection (DI)
• Middleware pipeline
• Authentication & Authorization
• Configuration
• Logging
• Routing
• API yapılandırmaları
• Entity Framework
• Security
• Caching
• Background services
• OpenTelemetry
• Rate limiting

gibi uygulamanın neredeyse tamamını yönetebilirsiniz.

Bu makalede .NET 10 ile birlikte Program.cs içerisinde yapılandırabileceğiniz önemli tüm alanları detaylı şekilde inceleyeceğiz.

Minimal ASP.NET Core Yapısı

Modern bir ASP.NET Core uygulaması genellikle şu şekilde başlar:

var builder = WebApplication.CreateBuilder(args);

// Servis kayıtları
builder.Services.AddControllers();

var app = builder.Build();

// Middleware pipeline
app.UseHttpsRedirection();

app.MapControllers();

app.Run();

Burada aslında iki temel aşama vardır:

1. Aşama

builder.Services ve Dependency Injection container’a servis ekleme

2.Aşama

app.Use / app.Map ve HTTP pipeline oluşturma

WebApplication.CreateBuilder(args) Ne Yapar?

var builder = WebApplication.CreateBuilder(args);

Bu satır aslında arka planda çok fazla şeyi otomatik olarak hazırlar:

• Kestrel web server
• Configuration sistemi
• Logging altyapısı
• Dependency Injection container
• Environment yönetimi
• IIS integration
• JSON configuration desteği

Eskiden:

Host.CreateDefaultBuilder()

ile yaptığımız işlemler artık otomatik geliyor.

Configuration Sistemi

ASP.NET Core’un configuration sistemi oldukça güçlüdür.

Varsayılan olarak şu kaynaklar otomatik yüklenir:

1. appsettings.json
2. appsettings.Development.json
3. User Secrets
4. Environment Variables
5. Command-line arguments

Örnek kullanım:

var connectionString =
    builder.Configuration.GetConnectionString("Default");

Ek configuration kaynakları ekleyebilirsiniz:

builder.Configuration
    .AddJsonFile("custom.json")
    .AddEnvironmentVariables();

Strongly Typed Configuration

Büyük projelerde ayarları class üzerinden yönetmek daha temizdir.

appsettings.json

{
  "MailSettings": {
    "Host": "smtp.example.com",
    "Port": 587
  }
}

Settings Class

public class MailSettings
{
    public string Host { get; set; }
    public int Port { get; set; }
}

Program.cs

builder.Services.Configure<MailSettings>(
    builder.Configuration.GetSection("MailSettings"));

Kullanım:

public class MailService
{
    private readonly MailSettings _settings;

    public MailService(IOptions<MailSettings> options)
    {
        _settings = options.Value;
    }
}

Dependency Injection (DI)

ASP.NET Core’un en güçlü özelliklerinden biri built-in DI sistemidir.

Singleton

Uygulama boyunca tek instance:

builder.Services.AddSingleton<IMyService, MyService>();

Scoped

Her request için yeni instance:

builder.Services.AddScoped<IMyService, MyService>();

Transient

Her kullanımda yeni instance:

builder.Services.AddTransient<IMyService, MyService>();

Logging Yapılandırması

ASP.NET Core built-in logging desteğiyle gelir.

builder.Logging.ClearProviders();

builder.Logging.AddConsole();

builder.Logging.AddDebug();

Çoğu production uygulamasında ise genellikle:

• Serilog
• NLog

tercih edilir.

Örnek Serilog:

builder.Host.UseSerilog();

Middleware Pipeline Mantığı

ASP.NET Core middleware tabanlı çalışır.

Pipeline sırası çok önemlidir.

Örnek:

app.UseHttpsRedirection();

app.UseAuthentication();

app.UseAuthorization();

app.MapControllers();

Request akışı:

Request
   ↓
Middleware
   ↓
Middleware
   ↓
Endpoint
   ↓
Response

Routing

Minimal API

app.MapGet("/", () => "Hello World");

Parametreli route:

app.MapGet("/users/{id:int}",
    (int id) => $"User {id}");

Route group:

var api = app.MapGroup("/api");

api.MapGet("/products", GetProducts);

Controllers & MVC

Controller desteği:

builder.Services.AddControllers();

MVC:

builder.Services.AddControllersWithViews();

Razor Pages:

builder.Services.AddRazorPages();

Endpoint mapping:

app.MapControllers();

app.MapRazorPages();

Authentication

JWT Authentication

Modern API projelerinde en yaygın yöntemdir.

builder.Services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = "https://identity.example.com";
        options.Audience = "api";
    });

Authorization

Policy bazlı authorization:

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AdminOnly",
        policy => policy.RequireRole("Admin"));
});

Controller tarafı:

[Authorize(Policy = "AdminOnly")]

Entity Framework Core

DbContext kaydı:

builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("Default")));

Popüler provider’lar:

• Microsoft SQL Server
• PostgreSQL
• SQLite

Migration:

dotnet ef migrations add Initial

dotnet ef database update

Swagger / OpenAPI

API dokümantasyonu için vazgeçilmezdir.

Kurulum:

dotnet add package Swashbuckle.AspNetCore

Program.cs:

builder.Services.AddEndpointsApiExplorer();

builder.Services.AddSwaggerGen();

Middleware:

app.UseSwagger();

app.UseSwaggerUI();

CORS Yapılandırması

Frontend-backend ayrık sistemlerde gereklidir.

builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowFrontend",
        policy =>
        {
            policy.WithOrigins("https://frontend.com")
                  .AllowAnyHeader()
                  .AllowAnyMethod();
        });
});

Pipeline:

app.UseCors("AllowFrontend");

Exception Handling

Production ortamında kritik öneme sahiptir.

app.UseExceptionHandler("/error");

Status code pages:

app.UseStatusCodePages();

RFC7807 standardı:

builder.Services.AddProblemDetails();

HTTPS & Güvenlik

HTTPS yönlendirmesi:

app.UseHttpsRedirection();

HSTS:

app.UseHsts();

Security header örneği:

app.Use(async (context, next) =>
{
    context.Response.Headers["X-Content-Type-Options"] = "nosniff";

    await next();
});

Static Files

app.UseStaticFiles();

Varsayılan klasör:

wwwroot/

Session Yönetimi

builder.Services.AddSession();

app.UseSession();

Cookie policy:

builder.Services.Configure<CookiePolicyOptions>(options =>
{
    options.MinimumSameSitePolicy = SameSiteMode.Strict;
});

Caching

Memory cache:

builder.Services.AddMemoryCache();

Redis cache:

builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = "localhost:6379";
});

Output cache:

builder.Services.AddOutputCache();

app.UseOutputCache();

Health Checks

Kubernetes ve Docker ortamlarında çok önemlidir.

builder.Services.AddHealthChecks();

app.MapHealthChecks("/health");

Background Services

Arka planda çalışan servisler:

builder.Services.AddHostedService<MyWorker>();

Örnek worker:

public class MyWorker : BackgroundService
{
    protected override async Task ExecuteAsync(
        CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await Task.Delay(1000);
        }
    }
}

SignalR

Gerçek zamanlı uygulamalar için:

builder.Services.AddSignalR();

app.MapHub<ChatHub>("/chat");

Kullanım alanları:

• Chat uygulamaları
• Notification sistemleri
• Canlı dashboard’lar

Rate Limiting

.NET’in built-in rate limiting desteği:

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("fixed", limiter =>
    {
        limiter.PermitLimit = 10;

        limiter.Window = TimeSpan.FromMinutes(1);
    });
});

Middleware:

app.UseRateLimiter();

Endpoint bazlı kullanım:

app.MapGet("/", () => "Hello")
   .RequireRateLimiting("fixed");

OpenTelemetry & Observability

Modern distributed sistemlerde artık standart hale geldi.

builder.Services.AddOpenTelemetry()
    .WithTracing(...)
    .WithMetrics(...);

En yaygın kullanılan araçlar:

• Jaeger
• Prometheus
• Grafana

HTTP Client Factory

builder.Services.AddHttpClient();

Named client:

builder.Services.AddHttpClient("github", client =>
{
    client.BaseAddress =
        new Uri("https://api.github.com");
});

Typed client:

builder.Services.AddHttpClient<MyApiClient>();

Reverse Proxy Desteği

Özellikle production ortamlarında önemlidir.

builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders =
        ForwardedHeaders.XForwardedFor |
        ForwardedHeaders.XForwardedProto;
});

Genellikle:

• NGINX
• Apache HTTP Server
• YARP

ile birlikte kullanılır.

Modern ASP.NET Core İçin Önerilen Middleware Sırası

app.UseForwardedHeaders();

app.UseExceptionHandler();

app.UseHsts();

app.UseHttpsRedirection();

app.UseStaticFiles();

app.UseRouting();

app.UseCors();

app.UseAuthentication();

app.UseAuthorization();

app.UseRateLimiter();

app.UseOutputCache();

app.MapControllers();

Middleware sırası gerçekten önemlidir.

Büyük Projelerde Program.cs Nasıl Yönetilmeli?

Büyük projelerde Program.cs dosyasını şişirmemek gerekir.

Kötü örnek:

builder.Services.AddScoped<...>();

builder.Services.AddScoped<...>();

builder.Services.AddScoped<...>();

Daha temiz yaklaşım:

builder.Services.AddApplication();

builder.Services.AddInfrastructure();

builder.Services.AddPersistence();

Extension method kullanımı büyük projelerde ciddi fark yaratır.

Sık Yapılan Hatalar

Middleware sırasını yanlış yazmak

Yanlış:

app.UseAuthorization();

app.UseAuthentication();

Doğru:

app.UseAuthentication();

app.UseAuthorization();

MapControllers() unutmak

Controller’lar çalışmaz.

Build() çağrısından sonra service eklemek

Yanlış:

var app = builder.Build();

builder.Services.AddControllers();

Tüm service registration işlemleri Build() öncesinde yapılmalıdır.

Sonuç

Modern ASP.NET Core uygulamalarında Program.cs:

• Uygulamanın startup merkezi
• Dependency graph builder
• HTTP pipeline yöneticisi
• Security configuration noktası
• Hosting orchestration katmanı

haline gelmiştir.

Program.cs dosyasını gerçekten anlamak:

• ASP.NET Core mimarisini
• Middleware mantığını
• Dependency Injection sistemini
• Modern backend yapılarını

anlamak demektir.

Özellikle .NET 10 ile birlikte minimal hosting modeli artık tamamen standart hale geldiği için, güçlü bir ASP.NET Core geliştiricisi olmak isteyen herkesin Program.cs yapısını derinlemesine öğrenmesi gerekir.