Software Engineer Encyclopedia
0%
Domain 03 · Backend Engineering & Web Development · Topic 3.4

الـ Dependency Injection في ASP.NET Core

Dependency Injection (DI)

الـ DI هو العمود الفقري لأي تطبيق ASP.NET Core: إزاي الـ container بيبني الـ objects، يعني إيه Lifetimes، ليه الـ Captive Dependency بتكسر الـ production، وإزاي تختبر وتصمم من غير ما تغرق في abstractions مالهاش لازمة.

  • Intermediate
  • ~24 min read
  • 14 sections
  • 22 code examples
  • 4 diagrams
  • 10 questions
  • Priority L1 · Essential
  • .NET 10 LTS · C# 14

المتطلبات قبل ما تبدأ

C# و.NET (المجال 02) والـ HTTP/Networking (درس 1.2).

مستوى التعمق المطلوب

DEEPUnderstand lifetimes and avoid lifetime-related bugs.

01

ليه محتاجين DI؟ (IoC vs DI)

Introduction · Inversion of Control vs Dependency Injection
Basics

قبل أي كود: تخيل إنك بتبني OrderService بيحفظ الأوردر في الداتابيز وبيبعت إيميل. أول حاجة بتيجي في بالك إنك تعمل new للحاجات اللي محتاجها جوه الـ class. الـ DI موجود عشان يحل المشكلة اللي بتطلع من الطريقة دي.

المشكلة: Tight Coupling

لما الـ class بيعمل new SqlOrderRepository() بنفسه، فهو بقى مربوط بالـ implementation دي بالذات. نتايج ده:

  • مينفعش تختبر OrderService من غير ما تكلم داتابيز حقيقية.
  • لو عايز تغير الإيميل من SMTP لـ SendGrid لازم تفتح الـ class وتعدل فيه.
  • الـ class لازم يعرف إزاي يبني كل dependency (connection string، settings…) فمسؤولياته بتكبر.

Inversion of Control (IoC)

مبدأ عام: بدل ما الكود بتاعك هو اللي يتحكم في إنشاء وإدارة الحاجات اللي بيستخدمها، بتقلب الاتجاه وحد تاني (framework أو container) هو اللي يتحكم. الـ IoC مش مرتبط بـ DI فقط؛ الـ events والـ callbacks والـ template method كلها شكل من IoC.

Dependency Injection (DI)

هو تقنية لتطبيق الـ IoC: الـ class بيعلن في الـ constructor «أنا محتاج IOrderRepository» ومش بيهمه مين اللي هيجيبه. حد من بره (الـ container) بيبني الـ object ويديه الـ dependency جاهزة.

الفرق في جملة واحدة

IoC هو المبدأ (أنا مش اللي بيتحكم)، و DI هو الأسلوب اللي بنطبقه بيه (الـ dependencies بتتحقن من بره)، و الـ DI Container هو الأداة اللي بتعمل الشغل ده أوتوماتيك (في ASP.NET Core هي Microsoft.Extensions.DependencyInjection).

قبل وبعد: كود حقيقي

C#Without DI — tight coupling (don't do this)
public class OrderService
{
    // The class decides WHICH implementations to use and HOW to build them.
    private readonly SqlOrderRepository _repo = new SqlOrderRepository("Server=.;Database=Shop;...");
    private readonly SmtpEmailSender _email = new SmtpEmailSender("smtp.company.com", 587);

    public void PlaceOrder(Order order)
    {
        _repo.Save(order);
        _email.Send(order.CustomerEmail, "Order received");
    }
}
C#With DI — the class only declares what it needs
public interface IOrderRepository { void Save(Order order); }
public interface IEmailSender     { void Send(string to, string subject); }

public class OrderService
{
    private readonly IOrderRepository _repo;
    private readonly IEmailSender _email;

    // Constructor Injection: dependencies arrive from outside.
    public OrderService(IOrderRepository repo, IEmailSender email)
    {
        _repo = repo;
        _email = email;
    }

    public void PlaceOrder(Order order)
    {
        _repo.Save(order);
        _email.Send(order.CustomerEmail, "Order received");
    }
}

شرح الكود

  1. النسخة الأولى: كل سطر new هو قرار hard-coded. أي تغيير في طريقة بناء الـ repository يضطرك تعدل OrderService.
  2. النسخة التانية: الـ class بقى بيعتمد على abstractions (IOrderRepository, IEmailSender) مش على implementations. ده مبدأ الـ Dependency Inversion من SOLID.
  3. الـ constructor هو «العقد»: أي حد عايز OrderService لازم يديه الاتنين. وده بيخلي الـ dependencies ظاهرة وصريحة بدل ما تكون مخفية جوه الـ methods.
  4. في الـ unit test تقدر تمرر fake implementations من غير أي container (هنشوفها في قسم Testing).
ليه ده يهم في الـ production؟

الـ DI هو اللي بيخلي تبديل implementation (Redis بدل MemoryCache، Stripe بدل PayPal) تعديل سطر واحد في الـ registration بدل تعديل 30 class. وهو كمان اللي بيخلي الـ framework نفسه (Logging, Options, HttpClientFactory, EF Core) يتركب جوه تطبيقك بنفس الطريقة.

02

الـ Container من جوه: Registration ثم Resolution

Core concepts · Service registration and resolution
Deep dive

الـ DI Container في ASP.NET Core بيشتغل على مرحلتين منفصلتين تماماً: (1) Registration بتقول فيها للـ container «لما حد يطلب X ادّيله Y بالـ lifetime ده»، و (2) Resolution وهي اللحظة اللي الـ container فعلاً بيبني فيها الـ object graph.

1 · Registration IServiceCollection List<ServiceDescriptor> AddScoped / AddSingleton 2 · Build BuildServiceProvider() Root ServiceProvider + ValidateOnBuild 3 · Scope CreateScope() HTTP request = 1 scope caches Scoped instances 4 · Resolve GetService(type) build graph recursively dispose at scope end Program.cs (startup, مرة واحدة) ←→ أثناء تشغيل التطبيق (مع كل request)
مراحل الـ DI Container: تسجيل → بناء الـ provider → scope لكل request → resolve للـ object graph

الـ Registration: ServiceDescriptor

كل سطر builder.Services.AddXxx بيضيف ServiceDescriptor للـ IServiceCollection. الـ descriptor فيه 3 معلومات: ServiceType (اللي الناس هتطلبه، غالباً interface)، ImplementationType أو factory أو instance (اللي هيتبني فعلاً)، و Lifetime.

C#Program.cs — registration styles
var builder = WebApplication.CreateBuilder(args);

// 1) Interface -> implementation (the most common form)
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();

// 2) Concrete type registered as itself (no interface)
builder.Services.AddTransient<PriceCalculator>();

// 3) Factory delegate: you control how the instance is created
builder.Services.AddSingleton<IClock>(sp =>
{
    var cfg = sp.GetRequiredService<IConfiguration>();
    return cfg.GetValue<bool>("UseFakeClock") ? new FakeClock() : new SystemClock();
});

// 4) A ready-made instance (the container will NOT dispose it)
builder.Services.AddSingleton<IEmailSender>(new SmtpEmailSender("smtp.company.com", 587));

var app = builder.Build();   // <-- the ServiceProvider is built here
app.Run();

شرح السطور المهمة

  1. WebApplication.CreateBuilder بيجهز builder.Services وفيه بالفعل مئات الـ registrations بتاعة الـ framework (Logging, Configuration, Routing…).
  2. الصيغة AddScoped<TService, TImplementation>() بتقول: لما حد يطلب IOrderRepository ابني SqlOrderRepository واحد لكل scope.
  3. الـ factory delegate بتتنفذ وقت الـ resolve مش وقت الـ registration، و الـ sp هو الـ provider الحالي. استخدمها لما بناء الـ object محتاج منطق أو config.
  4. الـ instance الجاهز (new SmtpEmailSender(...)) هو دايماً Singleton، وبما إنك انت اللي أنشأته فالـ container مش مسؤول عن الـ Dispose بتاعه.
  5. بعد Build() مبقاش ينفع تضيف registrations: الـ collection بتتحول لـ immutable provider.

Constructor Injection: إزاي الـ container يختار الـ constructor؟

الـ container بيشوف الـ constructors الـ public، ويختار اللي عنده أكبر عدد parameters يقدر يـ resolve كلهم. لو لقى constructor-ين ملهمش علاقة ببعض (ambiguity) هيرمي InvalidOperationException. كل parameter بيتعمله resolve بنفس الطريقة بشكل recursive، وده اللي بنسميه Object Graph.

C#OrderService.cs — constructor injection with a primary constructor (C# 12+)
public interface IClock { DateTimeOffset UtcNow { get; } }
public sealed class SystemClock : IClock { public DateTimeOffset UtcNow => DateTimeOffset.UtcNow; }

public interface IOrderRepository { Task SaveAsync(Order order, CancellationToken ct); }

public sealed class OrderService(
    IOrderRepository repo,
    IClock clock,
    ILogger<OrderService> logger)
{
    public async Task PlaceAsync(Order order, CancellationToken ct)
    {
        order.PlacedAt = clock.UtcNow;
        await repo.SaveAsync(order, ct);
        logger.LogInformation("Order {OrderId} placed at {At}", order.Id, order.PlacedAt);
    }
}

// Program.cs
builder.Services.AddSingleton<IClock, SystemClock>();
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.AddScoped<OrderService>();

app.MapPost("/orders", async (Order order, OrderService svc, CancellationToken ct) =>
{
    await svc.PlaceAsync(order, ct);
    return Results.Created($"/orders/{order.Id}", order);
});

تتبع التنفيذ خطوة بخطوة (Execution Trace)

الـ request POST /orders بيوصل. الـ ASP.NET Core بيعمل scope جديد للـ request ده.
الـ Minimal API عايز يـ bind الـ parameter OrderService svc. لقاه نوع مسجل في الـ container فبيطلب GetService(typeof(OrderService)) من scope الـ request.
الـ container بيشوف constructor الـ OrderService: محتاج IOrderRepository و IClock و ILogger<OrderService>.
IClock Singleton: لو أول مرة، بيبني SystemClock ويخزنه في الـ root. غير كده بيرجّع الـ instance الموجود.
IOrderRepository Scoped: بيبني SqlOrderRepository (وبيـ resolve الـ dependencies بتاعته بنفس الطريقة، زي AppDbContext) ويخزنه في الـ scope.
ILogger<OrderService> مسجل بالـ open generic بتاع الـ framework، فبيتبني لنوع OrderService.
بعد ما كل الـ dependencies جاهزة بيستدعي الـ constructor ويرجع الـ OrderService، والـ endpoint بيشتغل.
لما الـ response يخلص الـ scope بيتعمله Dispose: كل IDisposable بناه الـ container جوه الـ scope بيتعمله Dispose.
ملحوظة مهمة عن الـ Registration

لو سجلت نفس الـ service type أكتر من مرة، الـ resolve العادي (GetService<T>) بيرجّع آخر registration (last one wins). وطلب IEnumerable<T> بيرجّع كلهم بنفس ترتيب التسجيل. وفيه TryAddScoped بتسجل بس لو مفيش registration قبل كده (مفيدة لما تكتب library).

C#Multiple registrations
builder.Services.AddSingleton<INotifier, EmailNotifier>();
builder.Services.AddSingleton<INotifier, SmsNotifier>();

// Resolves SmsNotifier (last registration wins)
public class A(INotifier notifier) { }

// Resolves BOTH, in registration order: [EmailNotifier, SmsNotifier]
public class B(IEnumerable<INotifier> all) { }
03

الـ Lifetimes: Transient / Scoped / Singleton

Core concepts · Service lifetimes
Deep dive

الـ lifetime هو أهم قرار بتاخده لما تسجل أي service. هو بيحدد مين بيشارك الـ instance ده ومتى بيتعمل له Dispose. أغلب الـ bugs المؤلمة في الـ DI سببها lifetime غلط.

Transient

instance جديد في كل مرة يتطلب فيها. لو اتنين classes طلبوه في نفس الـ request هياخدوا نسختين مختلفتين.

stateless + خفيف allocations كتير لو تقيل

Scoped

instance واحد لكل scope. في ASP.NET Core الـ scope = الـ HTTP request. كل اللي بيطلبوه في نفس الـ request بيشاركوا نفس النسخة.

DbContext · Unit of Work · بيانات المستخدم الحالي

Singleton

instance واحد لكل التطبيق، بيتبني أول مرة ويعيش لحد ما التطبيق يقفل. لازم يكون thread-safe لأن requests كتير هتستخدمه في نفس الوقت.

Cache · Configuration · Clock · HttpClient factory

Lifetime HTTP Request #1 (Scope 1) HTTP Request #2 (Scope 2) Singleton Instance #A — الكل بيشاركه، بيعيش طول عمر التطبيق Scoped Instance #B1 Instance #B2 Transient #C1 #C2 #C3 #C4 injected مرتين → نسختينinjected مرتين → نسختين
نفس الـ 3 services عبر request-ين: Singleton نسخة واحدة، Scoped نسخة لكل request، Transient نسخة جديدة مع كل injection

مثال عملي يثبت الفرق

C#LifetimeDemo — prove it with Guids
public interface IIdService { Guid Id { get; } }

public sealed class TransientId : IIdService { public Guid Id { get; } = Guid.NewGuid(); }
public sealed class ScopedId    : IIdService { public Guid Id { get; } = Guid.NewGuid(); }
public sealed class SingletonId : IIdService { public Guid Id { get; } = Guid.NewGuid(); }

// Marker interfaces so we can register all three separately
public interface ITransientId : IIdService { }
public interface IScopedId    : IIdService { }
public interface ISingletonId : IIdService { }

// (classes implement their own marker interface in the real code)
builder.Services.AddTransient<ITransientId, TransientId>();
builder.Services.AddScoped<IScopedId, ScopedId>();
builder.Services.AddSingleton<ISingletonId, SingletonId>();

app.MapGet("/ids", (
    ITransientId t1, ITransientId t2,
    IScopedId s1,    IScopedId s2,
    ISingletonId g1, ISingletonId g2) => new
{
    transient = new { first = t1.Id, second = t2.Id, same = t1.Id == t2.Id },
    scoped    = new { first = s1.Id, second = s2.Id, same = s1.Id == s2.Id },
    singleton = new { first = g1.Id, second = g2.Id, same = g1.Id == g2.Id }
});

المخرجات المتوقعة

Calltransient.samescoped.samesingleton.sameالـ Guid بين الـ requests
GET /ids (request 1)falsetruetrue—
GET /ids (request 2)falsetruetruescoped Guid اتغير، singleton Guid نفسه
  1. الـ constructor بتاع كل class بيولّد Guid جديد، فالـ Guid هو «بصمة» الـ instance.
  2. الـ endpoint طلب كل نوع مرتين عشان نقارن: لو الـ Guid واحد يبقى نفس الـ instance.
  3. Transient: مرتين resolve = مرتين constructor = Guid مختلف.
  4. Scoped: الاتنين في نفس الـ scope فاتبنى مرة واحدة والتاني خد الـ cached instance.
  5. Singleton: نفس الـ Guid في كل الـ requests طول ما التطبيق شغال.

جدول القرار: أستخدم أنهي lifetime؟

السؤاللو الإجابة نعم
الـ service بيحتفظ بـ state خاص بالـ request الحالي أو بالـ DbContext؟Scoped
الـ service stateless تماماً وخفيف وبيتبني بسرعة؟Transient (أو Singleton لو thread-safe)
الـ service بيحتفظ بـ cache أو connection pool أو config ومشترك بين كل المستخدمين؟Singleton (لازم thread-safe)
مش متأكد؟ابدأ بـ Scoped، وغيّر بس لو القياس (profiling) أثبت إن ده مشكلة
قاعدة التوافق بين الـ Lifetimes

الـ service مسموح يعتمد على service عمرها أطول أو تساوي عمره فقط. Singleton ← Singleton ✅ · Scoped ← Singleton ✅ · Transient ← أي حاجة ✅ · لكن Singleton ← Scoped ❌ (ده الـ Captive Dependency، القسم الجاي).

04

تحت الغطا: إزاي بيحصل الـ Resolve بالظبط؟

Internal mechanics · What happens inside the service provider
Deep dive

مش لازم تحفظ أسماء الـ internal classes، لكن فهم الصورة العامة بيفسر بالظبط ليه الأخطاء بتطلع بالشكل اللي بتطلع بيه.

1) Root Provider و Scoped Providers

أول Build() بيطلع root provider. كل CreateScope() بيطلع scoped provider مربوط بالـ root. الـ Singletons بتتخزن في الـ root، والـ Scoped بتتخزن في الـ scope اللي طلبها، والـ Transient مش بتتخزن أصلاً (إلا لو implements IDisposable فبيتم تتبعها عشان تتعمل لها Dispose).

2) Call Sites

عند أول طلب لنوع معين، الـ container بيحلل الـ constructors ويبني خطة resolve (internally call site) فيها كل الـ dependencies recursively، وبيخزن الخطة دي. الطلبات الجاية مش بتعمل reflection من الأول؛ بتستخدم الخطة المخزنة (وفي الـ runtime الحديث بيتم compile لـ expression / IL للسرعة).

3) Disposal

الـ container بيعمل Dispose لأي IDisposable/IAsyncDisposable هو اللي أنشأه لما الـ scope (أو الـ root) يتقفل. الـ instances اللي سجلتها جاهزة (AddSingleton(instance)) مش مسؤوليته.

EndpointPOST /orders OrderServiceScoped IOrderRepository → SqlOrderRepositoryScoped AppDbContext (Scoped) IClock → SystemClock (Singleton) ILogger<OrderService> (Singleton) needs
Dependency graph اللي الـ container بيبنيه لـ OrderService (كل مربع = service مع الـ lifetime بتاعه)
ليه ده مفيد في الـ debugging؟

لما تشوف Unable to resolve service for type 'X' while attempting to activate 'Y' فده معناه إن الـ container وهو بيبني الـ graph لـ Y ملقاش registration لـ X. ابدأ من الـ constructor بتاع Y وشوف الـ dependency الناقصة بالاسم.

05

Captive Dependencies و Scope Validation

Common mistake · Lifetime mismatch
Pitfalls

ده أخطر وأشهر خطأ في الـ DI. بيحصل لما service ليها عمر طويل (Singleton) تحتفظ بـ reference لـ service عمرها أقصر (Scoped). الـ dependency القصيرة بتبقى «محبوسة» (captive) جوه الـ Singleton وبتعيش أطول بكتير من اللي المفروض.

Singleton ReportService (lives for the whole app) private readonly AppDbContext _db; // injected once, in the constructor Request 1 / Scope 1 AppDbContext #1 Request 2 / Scope 2 AppDbContext #2 (ignored) captive! Scope 1 ends: DbContext #1 disposed, Singleton still holds it
الـ Singleton بيمسك أول DbContext اتعمل في Request 1، وبيفضل يستخدمه حتى بعد ما الـ scope بتاعه اتقفل

الكود الغلط

C#❌ Captive dependency
public class ReportService   // registered as Singleton
{
    private readonly AppDbContext _db;           // Scoped!

    public ReportService(AppDbContext db) => _db = db;

    public Task<int> CountOrdersAsync() => _db.Orders.CountAsync();
}

builder.Services.AddDbContext<AppDbContext>(o => o.UseSqlServer(cs));  // Scoped by default
builder.Services.AddSingleton<ReportService>();                          // BUG

إيه المشاكل اللي بتطلع؟

  • DbContext مش thread-safe، والـ Singleton بيتستخدم من requests متزامنة، فهتشوف A second operation was started on this context instance أو corruption في الـ change tracker.
  • الـ DbContext بيفضل يتراكم فيه tracked entities (memory leak) وبيشوف بيانات قديمة (stale).
  • الـ connection ممكن تتقفل أو تتعمل لها dispose بنهاية أول scope، فتحصل ObjectDisposedException بعد كده.

Scope Validation: الحماية الأوتوماتيك

الـ container قادر يكتشف الغلطة دي ويرمي exception واضح: Cannot consume scoped service 'AppDbContext' from singleton 'ReportService'. ده بيتفعل بإعدادين: ValidateScopes (يتأكد من قواعد الـ lifetimes وقت الـ resolve) و ValidateOnBuild (يجرب يبني كل الـ registrations وقت Build() فيطلع الخطأ عند الـ startup بدل ما يستنى أول request). الـ host الافتراضي في ASP.NET Core بيفعّلهم تلقائياً في بيئة Development فقط، لأن فيه تكلفة وقت الـ startup.

C#Enable validation explicitly (also for Production / non-web hosts)
var builder = WebApplication.CreateBuilder(args);

builder.Host.UseDefaultServiceProvider(options =>
{
    options.ValidateScopes  = true;   // catches Singleton -> Scoped at resolve time
    options.ValidateOnBuild = true;   // catches missing registrations/mismatches at startup
});

شرح

  1. UseDefaultServiceProvider بيعدّل ServiceProviderOptions اللي بيُبنى بيها الـ provider.
  2. مع ValidateScopes = true: أي محاولة لـ resolve scoped service من الـ root provider أو من singleton بترمي exception.
  3. مع ValidateOnBuild = true: builder.Build() هيفشل لو في أي service مش قادر الـ container يبنيها (dependency ناقصة).
  4. الـ trade-off: الـ startup أبطأ شوية، لكن بتكتشف الأخطاء قبل ما أي مستخدم يشوفها. فكّر في تفعيلها في الـ CI/integration tests على الأقل.

الحلول الصح

الحل 1: وافق بين الـ lifetimes

الأسهل غالباً: خلي ReportService نفسه Scoped. معظم الـ business services المفروض تبقى scoped أصلاً لأنها بتتعامل مع الـ DbContext.

الحل 2: افتح scope يدوي

لو لازم الـ service تبقى Singleton (مثلاً service بتتشغل في background) حقن IServiceScopeFactory وافتح scope لكل عملية (القسم الجاي).

06

IServiceScopeFactory و DI في الـ Background Services

Creating scopes manually · BackgroundService
Practical

الـ BackgroundService / IHostedService بيتسجل كـ Singleton وبيشتغل برّه أي HTTP request، فمفيش «scope» تلقائي. أي استخدام للـ DbContext أو أي scoped service جواه لازم يتم عن طريق scope تفتحه انت.

C#OrderCleanupWorker.cs
public sealed class OrderCleanupWorker(
    IServiceScopeFactory scopeFactory,
    ILogger<OrderCleanupWorker> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(5));

        while (await timer.WaitForNextTickAsync(stoppingToken))
        {
            // New scope for EACH unit of work
            await using var scope = scopeFactory.CreateAsyncScope();

            var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
            var cutoff = DateTime.UtcNow.AddDays(-30);

            var deleted = await db.Orders
                .Where(o => o.Status == OrderStatus.Cancelled && o.CreatedAt < cutoff)
                .ExecuteDeleteAsync(stoppingToken);

            logger.LogInformation("Cleanup removed {Count} orders", deleted);
        }   // scope disposed here -> DbContext disposed
    }
}

// Program.cs
builder.Services.AddHostedService<OrderCleanupWorker>();

شرح

  1. IServiceScopeFactory نفسه Singleton آمن، فينفع تتحقن في أي Singleton.
  2. CreateAsyncScope() بيرجع AsyncServiceScope بنستخدمه مع await using عشان الـ Dispose يشتغل صح (بما فيها IAsyncDisposable).
  3. من scope.ServiceProvider بنطلب أي scoped service؛ كل اللي بيتعمل في نفس الـ scope بيشارك نفس الـ DbContext.
  4. كل تكرار في الـ loop = unit of work جديد بـ DbContext جديد. ده بيحمي من تراكم الـ tracked entities.
  5. ExecuteDeleteAsync بيعمل DELETE مباشر في الـ SQL من غير ما يحمل الـ entities في الذاكرة.
بديل: IDbContextFactory

لو الـ Singleton محتاج DbContext بس، ممكن تسجل AddDbContextFactory<AppDbContext>() وتحقن IDbContextFactory<AppDbContext> وتستدعي CreateDbContext() لكل عملية، من غير ما تتعامل مع scopes يدوي.

نفس المشكلة في الـ Middleware

الـ convention-based middleware بيتبني مرة واحدة (مثل Singleton). متحقنش scoped service في الـ constructor بتاعه. خليه parameter في InvokeAsync(HttpContext ctx, IScopedService s) وهيتحقن من scope الـ request.

C#Middleware — scoped dependency goes into InvokeAsync
public sealed class TenantMiddleware(RequestDelegate next)       // constructed ONCE
{
    public async Task InvokeAsync(HttpContext ctx, ITenantProvider tenants)  // resolved PER REQUEST
    {
        tenants.Current = ctx.Request.Headers["X-Tenant"].ToString();
        await next(ctx);
    }
}
07

الـ Options Pattern

Strongly-typed configuration through DI
Practical

بدل ما تقرا configuration["Smtp:Host"] بالـ string في كل مكان، بتربط section من الـ config بـ class عادي (POCO) وتحقنه. ده بيدّيك type safety و validation وإمكانية reload.

JSONappsettings.json
{
  "Smtp": {
    "Host": "smtp.company.com",
    "Port": 587,
    "From": "noreply@company.com"
  }
}
C#SmtpOptions + registration with validation
using System.ComponentModel.DataAnnotations;

public sealed class SmtpOptions
{
    public const string SectionName = "Smtp";

    [Required] public string Host { get; init; } = "";
    [Range(1, 65535)] public int Port { get; init; } = 25;
    [Required, EmailAddress] public string From { get; init; } = "";
}

// Program.cs
builder.Services
    .AddOptions<SmtpOptions>()
    .Bind(builder.Configuration.GetSection(SmtpOptions.SectionName))
    .ValidateDataAnnotations()
    .ValidateOnStart();          // fail fast at startup if config is invalid

// Consumer
public sealed class SmtpEmailSender(IOptions<SmtpOptions> options) : IEmailSender
{
    private readonly SmtpOptions _o = options.Value;
    public void Send(string to, string subject) { /* use _o.Host, _o.Port ... */ }
}

شرح

  1. Bind بيملا خصائص SmtpOptions من section الـ Smtp (اسم الـ section مش حساس لحالة الأحرف).
  2. ValidateDataAnnotations بيطبق الـ attributes، و ValidateOnStart بيخلي التحقق يحصل وقت بدء التطبيق مش عند أول استخدام.
  3. بنحقن IOptions<SmtpOptions> مش SmtpOptions مباشرة، و .Value بيرجّع النسخة المربوطة.

أي interface أستخدم؟

InterfaceLifetimeبيشوف تغيير الـ config؟استخدمه لما…
IOptions<T>Singletonلا (قيمة ثابتة بعد أول قراءة)الإعدادات ثابتة طول تشغيل التطبيق
IOptionsSnapshot<T>Scopedنعم، مرة لكل requestعايز config متحدث بين الـ requests (مينفعش يتحقن في Singleton)
IOptionsMonitor<T>Singletonنعم، مع OnChange notificationsSingletons / background services محتاجة تشوف التغيير
Captive dependency مستخبية

لو حاولت تحقن IOptionsSnapshot<T> (Scoped) في Singleton هتواجه نفس مشكلة الـ lifetimes. للـ singletons استخدم IOptionsMonitor<T>. وكمان لو عملت Configure<T> بـ dependencies من الـ DI، استخدم singleton services فقط جواها (متستخدمش DbContext).

08

Open Generics و Keyed Services

Open generics · Keyed services (.NET 8+)
Practical

Open Generics

بدل ما تسجل IRepository<Order> و IRepository<Customer> و… كل واحد لوحده، بتسجل النوع المفتوح مرة واحدة والـ container بيقفله (closes it) تلقائياً وقت الـ resolve. ده نفس الـ trick اللي بيخلي ILogger<T> يشتغل لأي T.

C#Open generic registration
public interface IRepository<T> where T : class
{
    Task<T?> GetAsync(int id, CancellationToken ct);
    Task AddAsync(T entity, CancellationToken ct);
}

public sealed class EfRepository<T>(AppDbContext db) : IRepository<T> where T : class
{
    public Task<T?> GetAsync(int id, CancellationToken ct) => db.Set<T>().FindAsync([id], ct).AsTask();
    public async Task AddAsync(T entity, CancellationToken ct) { db.Set<T>().Add(entity); await db.SaveChangesAsync(ct); }
}

// ONE line covers every entity type
builder.Services.AddScoped(typeof(IRepository<>), typeof(EfRepository<>));

// Usage: the container closes the generic automatically
public sealed class CustomerService(IRepository<Customer> customers) { }   // -> EfRepository<Customer>
  1. typeof(IRepository<>) (الأقواس الفاضية) بتعني open generic type definition.
  2. لما CustomerService يطلب IRepository<Customer> الـ container بيبني EfRepository<Customer> ويحقنه فيه AppDbContext المناسب.
  3. تحذير تصميمي: الـ generic repository فوق EF Core غالباً abstraction زيادة لأن DbContext نفسه هو Repository و Unit of Work (شوف قسم «امتى متضيفش abstraction»).

Keyed Services

لما يكون عندك أكتر من implementation لنفس الـ interface وعايز تختار بينهم بالاسم، من ‎.NET 8 فيه Keyed Services: بتسجل بـ key وبتطلب بنفس الـ key.

C#Keyed services
public interface ICache { Task<string?> GetAsync(string key); }
public sealed class MemoryCacheImpl : ICache { /* ... */ public Task<string?> GetAsync(string key) => Task.FromResult<string?>(null); }
public sealed class RedisCacheImpl  : ICache { /* ... */ public Task<string?> GetAsync(string key) => Task.FromResult<string?>(null); }

builder.Services.AddKeyedSingleton<ICache, MemoryCacheImpl>("local");
builder.Services.AddKeyedSingleton<ICache, RedisCacheImpl>("distributed");

public sealed class ProductService(
    [FromKeyedServices("local")] ICache local,
    [FromKeyedServices("distributed")] ICache distributed)
{
}

// Manual resolution (rare)
var redis = serviceProvider.GetRequiredKeyedService<ICache>("distributed");
  1. AddKeyedSingleton<TService, TImpl>(key) بيسجل الـ implementation تحت الـ key (الـ key object، غالباً string أو enum).
  2. [FromKeyedServices("local")] على الـ parameter بيقول للـ container أي registration يستخدم.
  3. الـ registration العادي (من غير key) والـ keyed بيعيشوا جنب بعض ومبيتداخلوش.
  4. استخدمها بحذر: لو لقيت نفسك بتختار الـ implementation بالـ key في كل مكان، ممكن تكون محتاج strategy/factory صريح.
09

الاختبار مع الـ DI

Testing with DI
Practical

أكبر فايدة عملية للـ DI هي الاختبار. فيه مستويين: unit tests من غير container أصلاً، و integration tests بتشغل التطبيق كله وتبدّل services معينة.

1) Unit test: من غير Container

C#OrderServiceTests.cs (xUnit)
public sealed class FakeClock(DateTimeOffset now) : IClock { public DateTimeOffset UtcNow { get; } = now; }

public sealed class InMemoryOrderRepository : IOrderRepository
{
    public List<Order> Saved { get; } = [];
    public Task SaveAsync(Order order, CancellationToken ct) { Saved.Add(order); return Task.CompletedTask; }
}

public class OrderServiceTests
{
    [Fact]
    public async Task PlaceAsync_stamps_time_and_saves()
    {
        // Arrange: build the object by hand — no container needed
        var now  = new DateTimeOffset(2026, 1, 1, 10, 0, 0, TimeSpan.Zero);
        var repo = new InMemoryOrderRepository();
        var sut  = new OrderService(repo, new FakeClock(now), NullLogger<OrderService>.Instance);

        // Act
        var order = new Order { Id = 1 };
        await sut.PlaceAsync(order, CancellationToken.None);

        // Assert
        Assert.Equal(now, order.PlacedAt);
        Assert.Single(repo.Saved);
    }
}
  1. لأن OrderService بياخد dependencies في الـ constructor، نقدر نعمل new OrderService(...) بـ fakes بسيطة.
  2. الـ FakeClock بيخلي الوقت deterministic؛ بدون IClock الاختبار ده مستحيل يبقى مضمون.
  3. NullLogger<T>.Instance جاي من Microsoft.Extensions.Logging.Abstractions.
  4. القاعدة: unit test الـ class مباشرة، متبنيش container في الـ unit tests.

2) Integration test: تبديل service داخل التطبيق

C#WebApplicationFactory — replace a service in tests
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;

public sealed class ApiFactory : WebApplicationFactory<Program>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureTestServices(services =>
        {
            services.RemoveAll<IEmailSender>();                       // drop the real one
            services.AddSingleton<IEmailSender, FakeEmailSender>();   // register a fake
        });
    }
}

public class OrdersApiTests(ApiFactory factory) : IClassFixture<ApiFactory>
{
    [Fact]
    public async Task Post_orders_returns_created()
    {
        var client = factory.CreateClient();
        var res = await client.PostAsJsonAsync("/orders", new { Id = 7 });
        Assert.Equal(HttpStatusCode.Created, res.StatusCode);
    }
}
  1. WebApplicationFactory<Program> بيشغل التطبيق الحقيقي in-memory (محتاج public partial class Program {} لو بتستخدم top-level statements).
  2. ConfigureTestServices بيشتغل بعد registrations التطبيق، فبيقدر يستبدلها.
  3. RemoveAll<T> بتشيل كل الـ registrations القديمة قبل ما تضيف الـ fake، عشان متبقاش عندك اتنين.
  4. الفحص الـ end-to-end بيتم عن طريق HttpClient بيتكلم مع الـ TestServer.
10

قرارات التصميم: Composition Root، Service Locator، وامتى متضيفش Abstraction

Engineering decisions
Deep dive

Composition Root

هو المكان الواحد اللي بتجمع فيه كل الـ registrations وبتعرف فيه الـ object graph، وفي ASP.NET Core هو Program.cs (أو extension methods منظمة بتتنادى منه). الانضباط ده يعني: الـ container بيتعرف فقط عند الـ startup، وباقي الكود بيستقبل dependencies من غير ما يعرف إن فيه container أصلاً.

C#Organizing the composition root with extension methods
// Program.cs stays short and readable
builder.Services
    .AddApplicationServices()
    .AddInfrastructure(builder.Configuration);

// ServiceCollectionExtensions.cs
public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddApplicationServices(this IServiceCollection services)
    {
        services.AddScoped<OrderService>();
        services.AddSingleton<IClock, SystemClock>();
        return services;
    }

    public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration cfg)
    {
        services.AddDbContext<AppDbContext>(o => o.UseSqlServer(cfg.GetConnectionString("Default")));
        services.AddScoped<IOrderRepository, SqlOrderRepository>();
        return services;
    }
}

Service Locator Anti-pattern

الـ Service Locator هو إنك تحقن IServiceProvider (أو تستخدم HttpContext.RequestServices) وتطلب الـ dependencies بنفسك من جوه الـ methods. المشكلة إن الـ dependencies بتبقى مخفية: مفيش constructor بيقول الـ class محتاج إيه، فالاختبار صعب والأخطاء بتظهر وقت التشغيل مش وقت البناء.

C#❌ Service Locator vs ✅ Explicit dependencies
// ❌ hidden dependencies, fails at runtime if not registered
public class BadOrderService(IServiceProvider sp)
{
    public void Place(Order o)
    {
        var repo = sp.GetRequiredService<IOrderRepository>();
        var mail = sp.GetRequiredService<IEmailSender>();
        // ...
    }
}

// ✅ the constructor is the contract
public class GoodOrderService(IOrderRepository repo, IEmailSender mail)
{
    public void Place(Order o) { /* ... */ }
}
إمتى الـ IServiceProvider مقبول؟

داخل الـ composition root، جوه factories صغيرة، أو لما تفتح scope يدوي زي مثال الـ BackgroundService. الفكرة إن استخدامه يبقى استثناء محصور مش عادة في كل الـ business classes.

امتى متضيفش Abstraction؟

مش كل class لازم ليه interface. إضافة IFoo لـ Foo وهو implementation وحيد ومش هيتبدل ولا محتاج mock هي ceremony بتزود عدد الملفات وبتصعب التنقل في الكود من غير أي فايدة.

✅ ضيف interface لما…

  • فيه boundary خارجي (database, HTTP, file system, clock, email).
  • محتاج تبدّل الـ implementation (Stripe/PayPal).
  • محتاج fake في الاختبار لأن الـ dependency بطيئة أو non-deterministic.
  • بتكتب library والمستهلكين لازم يستبدلوا حاجات.

❌ متضيفش لما…

  • class بيعمل منطق داخلي بحت (pure logic) ويتختبر مباشرة.
  • Interface بنفس شكل الـ class بالظبط وبنسخة واحدة (IOrderMapper / OrderMapper).
  • بتلف حاجة الـ framework عاملها أصلاً (مثلاً IRepository فوق DbContext بدون سبب).
11

Scrutor و Factory Delegates (Func<T>)

Assembly scanning · Decoration · Factories
Practical

Scrutor: Assembly Scanning و Decoration

الـ built-in container بسيط ومفيهوش scanning ولا decoration. Scrutor هي مكتبة طرف تالت (NuGet package اسمها Scrutor) بتضيف extension methods على IServiceCollection للحاجتين دول.

C#Scrutor — scan + decorate
// dotnet add package Scrutor
builder.Services.Scan(scan => scan
    .FromAssemblyOf<OrderService>()
    .AddClasses(c => c.Where(t => t.Name.EndsWith("Service")))
    .AsSelf()
    .WithScopedLifetime());

// Decoration: wrap an existing registration with cross-cutting behaviour
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.Decorate<IOrderRepository, CachedOrderRepository>();

public sealed class CachedOrderRepository(IOrderRepository inner, IMemoryCache cache) : IOrderRepository
{
    public async Task<Order?> GetAsync(int id, CancellationToken ct) =>
        await cache.GetOrCreateAsync(id, _ => inner.GetAsync(id, ct));

    public Task SaveAsync(Order order, CancellationToken ct) => inner.SaveAsync(order, ct);
}
  1. Scan بيفحص الـ assembly بالـ reflection وقت الـ startup ويسجل الـ classes اللي تطابق الشرط، فمتحتاجش تكتب سطر لكل service.
  2. Decorate<TService, TDecorator> بيغيّر الـ registration الموجودة: لما حد يطلب IOrderRepository يرجّعله CachedOrderRepository اللي جواه الـ SqlOrderRepository الأصلي.
  3. الـ decorator بيستقبل الـ inner في constructor بتاعه، فنفس مبدأ الـ DI بيتطبق.
  4. Trade-off: scanning بيخبي أي class اتسجل ومنين، وده بيصعب الـ debugging. استخدمه بشروط محددة وواضحة، مش AddClasses() على كل حاجة.

Factory Delegates: Func<T> و Factories

الـ Microsoft DI container مبيدعمش Func<T> و Lazy<T> أوتوماتيك (عكس Autofac مثلاً). لو محتاج تنشئ instances جديدة وقت التشغيل أو تأجل الإنشاء، لازم تسجل الـ factory بنفسك.

C#Registering Func<T> and a named factory
public interface IReportGenerator { string Generate(); }
public sealed class PdfReport : IReportGenerator { public string Generate() => "pdf"; }
public sealed class CsvReport : IReportGenerator { public string Generate() => "csv"; }

builder.Services.AddTransient<PdfReport>();
builder.Services.AddTransient<CsvReport>();

// Func<T>: lets the consumer create instances on demand
builder.Services.AddTransient<Func<PdfReport>>(sp => () => sp.GetRequiredService<PdfReport>());

// Factory by name: choose the implementation at runtime
builder.Services.AddSingleton<Func<string, IReportGenerator>>(sp => format => format switch
{
    "pdf" => sp.GetRequiredService<PdfReport>(),
    "csv" => sp.GetRequiredService<CsvReport>(),
    _     => throw new ArgumentException($"Unknown format: {format}")
});

public sealed class ReportController(Func<string, IReportGenerator> factory)
{
    public string Export(string format) => factory(format).Generate();
}
  1. الـ lambda () => sp.GetRequiredService<PdfReport>() بتتأخر لحد ما حد يستدعيها، فكل استدعاء = resolve جديد.
  2. تحذير: الـ factory اللي مسجلة Singleton وبتـ capture الـ sp (root) هتعمل resolve لـ scoped services من الـ root وده خطأ. خلي الـ factory تـ resolve بس transient/singleton، أو سجلها Scoped.
  3. لو العدد قليل ومعروف، Keyed Services أنظف. استخدم الـ factory لما الاختيار بيعتمد على قيمة runtime حقيقية.
12

أخطاء شائعة وإزاي تكتشفها

Common mistakes and troubleshooting
Pitfalls
الخطأالعَرَضالسببالحل
Singleton بيحقن Scoped/DbContextCannot consume scoped service… أو second operation started on this contextCaptive dependencyغيّر الـ lifetime، أو IServiceScopeFactory، أو IDbContextFactory
نسيان تسجيل serviceUnable to resolve service for type…مفيش descriptor للنوعسجل النوع. فعّل ValidateOnBuild عشان يطلع وقت الـ startup
Circular dependency (A يحتاج B و B يحتاج A)A circular dependency was detected for the service of type…تصميم: مسؤوليات متداخلةاكسر الدايرة بـ abstraction ثالثة أو أعد توزيع المسؤوليات (مش بالـ lazy hack)
Transient IDisposable بيتحقن في Singleton / rootMemory leak بيكبر مع الوقتالـ container بيتتبع كل disposable transient لحد ما الـ scope يخلص (والـ root scope مبيخلصش إلا بإغلاق التطبيق)خليه Scoped، أو افتح scope قصير العمر
Constructor بيحتاج 8-10 dependenciesصعب الاختبار والقراءةالـ class بيعمل حاجات كتير (Single Responsibility)قسّمه لـ classes أصغر؛ متخبيش المشكلة بـ IServiceProvider
Scoped service في constructor بتاع MiddlewareException أو state مشترك بين requestsالـ middleware convention بيتبني مرة واحدةحطه parameter في InvokeAsync
Resolve جوه loop ساخنةضغط على الـ GC وبطءبتعمل allocations لكل transientresolve مرة بره الـ loop

إزاي تـ debug؟

  1. اقرا رسالة الـ exception من الآخر: بتقولك مين بيحاول يبني مين بالترتيب (…while attempting to activate 'X').
  2. فعّل ValidateScopes و ValidateOnBuild في الـ Development (مفعّلين افتراضياً) وفي الـ integration tests.
  3. لو سلوك غريب في state: اتأكد من الـ lifetime، وتأكد إن مفيش service Singleton بتحتفظ بـ mutable state من غير lock.
13

الأداء والمفاضلات

Performance and decision guide
Basics
  • Singleton: أرخص (instance واحد). بس لازم thread-safe، وأي mutable state بيحتاج مزامنة.
  • Scoped: allocation واحد لكل request لكل service، وده تكلفة صغيرة جداً عادةً.
  • Transient: allocation جديد لكل resolve. مع objects تقيلة أو كتير في الـ hot path بتزود ضغط الـ GC. مع IDisposable بتزود كمان التتبع.
  • تكلفة الـ resolve نفسها قليلة بعد أول مرة (call site cached)، فالاختناق الحقيقي غالباً في الـ I/O مش في الـ DI. قيس قبل ما تحسّن.
  • ValidateOnBuild بيزود وقت الـ startup في التطبيقات الكبيرة؛ ده سبب إنه مش مفعّل افتراضياً في Production.
البديلمميزاتهعيوبه
Microsoft.Extensions.DependencyInjection (الافتراضي)مدمج، بسيط، سريع، بيستخدمه كل الـ frameworkمفيهوش decoration/scanning/property injection/Func<T> جاهز
Autofac / LamarFeatures أكتر (modules, decorators, Func/Lazy, property injection)تعقيد زيادة وتبعية خارجية؛ متحتاجهوش غالباً
Manual DI ("Pure DI")أبسط حاجة ممكنة، compile-time safety كاملالـ composition root بيكبر ومبيتكاملش مع الـ framework
14

Knowledge Check

Takeaways · conceptual questions · code reading · interview
Basics

أهم النقاط

  • الـ DI = الـ class بيعلن احتياجاته في الـ constructor والـ container هو اللي يبني ويحقن. ده بيحقق Dependency Inversion والاختبار السهل.
  • الـ lifetime قرار تصميمي: Transient جديد دايماً، Scoped لكل request، Singleton للتطبيق كله (thread-safe).
  • Singleton ← Scoped ممنوع (Captive Dependency). فعّل ValidateScopes/ValidateOnBuild.
  • أي Singleton محتاج scoped service يفتح scope بـ IServiceScopeFactory (أو يستخدم IDbContextFactory).
  • الـ Options pattern بيدّيك config strongly-typed مع validation؛ اختار IOptions/Snapshot/Monitor حسب الـ lifetime.
  • Service Locator = dependencies مخفية؛ تجنبه إلا في الـ composition root.
  • مش كل class محتاج interface؛ حط abstractions عند الـ boundaries الحقيقية.

أسئلة مفاهيمية

ما الفرق بين IoC و DI و DI Container؟

IoC مبدأ: التحكم في إنشاء الـ dependencies بيتنقل برا الـ class. DI أسلوب تطبيقه: الـ dependencies بتتحقن (غالباً في الـ constructor). الـ Container أداة بتبني الـ object graph وتدير الـ lifetimes أوتوماتيك.

ليه الـ Captive Dependency خطيرة حتى لو الكود اشتغل في الـ Development؟

لأنها بتظهر كـ race conditions و stale data و memory growth تحت load حقيقي. الـ scope validation في Development بيمنعها، لكن لو اتعطل أو لو الـ bug اتعمل بـ IServiceProvider يدوي ممكن تعدي. وفي Production غالباً الـ validation مقفول.

IOptions و IOptionsSnapshot و IOptionsMonitor: أيهم يتحقن في Singleton؟

IOptions<T> (لو الـ config ثابت) أو IOptionsMonitor<T> (لو عايز التحديثات). أما IOptionsSnapshot<T> فـ Scoped، فحقنه في Singleton captive dependency.

لو سجلت نفس الـ interface مرتين بـ implementations مختلفة، إيه اللي بيتحقن؟

في GetService<T> وفي constructor parameter عادي: آخر registration. لو الـ parameter IEnumerable<T> هتاخد كلهم بترتيب التسجيل.

ليه BackgroundService مش ينفع يحقن DbContext مباشرة؟

لأن الـ BackgroundService Singleton، والـ DbContext Scoped (وغير thread-safe). الحل: IServiceScopeFactory و scope لكل unit of work، أو IDbContextFactory<T>.

قراءة كود

C#What's wrong here?
builder.Services.AddScoped<IUserContext, HttpUserContext>();
builder.Services.AddSingleton<AuditLogger>();

public class AuditLogger(IUserContext user, ILogger<AuditLogger> log)
{
    public void Log(string action) => log.LogInformation("{User} did {Action}", user.UserName, action);
}
إيه المشكلة؟ وإزاي تصلحها؟

AuditLogger Singleton وبيحقن IUserContext Scoped، يعني هيمسك أول مستخدم ويستخدمه لكل الـ requests (وهيتسجل اسم المستخدم الغلط في الـ audit!). الحلول: (1) خلي AuditLogger Scoped، أو (2) خلي Log تاخد userName كـ parameter من الـ caller.

C#Predict the output
builder.Services.AddTransient<Foo>();
builder.Services.AddScoped<Bar>();

app.MapGet("/x", (Foo a, Foo b, Bar c, Bar d) => new { foo = ReferenceEquals(a, b), bar = ReferenceEquals(c, d) });
الناتج المتوقع؟

{ foo: false, bar: true } لأن Foo Transient (نسختين) و Bar Scoped (نسخة واحدة داخل الـ request).

أسئلة إنترفيو شائعة

إزاي تحمي نفسك من lifetime bugs في فريق كبير؟

تفعيل ValidateScopes و ValidateOnBuild في الـ CI، integration test بيبني التطبيق كله، code review بيدور على IServiceProvider في الـ business code، وقاعدة إن الـ services الافتراضية Scoped.

امتى تفضل Pure DI على الـ container؟

في التطبيقات الصغيرة أو الـ libraries أو لما عايز compile-time safety كامل ومفيش حاجة من الـ framework محتاجة الـ container. في ASP.NET Core غالباً بنستخدم الـ container المدمج لأن الـ framework نفسه معتمد عليه.

الفرق بين Strategy pattern و Keyed Services؟

الـ Keyed Services هي آلية اختيار من الـ container للـ implementation بالاسم. الـ Strategy هو pattern تصميمي: كائنات بتبدّل خوارزمية. ممكن تستخدم Keyed Services كـ wiring للـ strategies، لكن لو الاختيار بمنطق runtime معقد، factory/strategy resolver صريح أفضل.

↗

المراجع والقراءة الإضافية

References & further reading

الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)

مصادر تعليمية ومتقدمة — Third-party & advanced reading

خريطة التغطية: 17 عنصر من الـ Roadmap ومكان شرحه في الدرس
RoadmapIoC vs DI§01
RoadmapConstructor Injection§02
RoadmapTransient, Scoped, and Singleton Lifetimes§03
RoadmapService Registration and Resolution§02
RoadmapCaptive Dependencies§05
RoadmapScope Validation§05
RoadmapIServiceScopeFactory§06
RoadmapOptions Pattern§07
RoadmapOpen Generics§08
RoadmapKeyed Services Basics§08
RoadmapDI in Background Services§06
RoadmapTesting with DI§09
RoadmapWhen Not to Add Abstractions§10
SuggestedScrutor: assembly scanning and decoration§11
SuggestedComposition root discipline§10
SuggestedService Locator anti-pattern§10
SuggestedFactory delegates (Func<T>)§11

خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.

محتويات الدرس