ليه محتاجين DI؟ (IoC vs DI)
قبل أي كود: تخيل إنك بتبني 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).
قبل وبعد: كود حقيقي
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");
}
}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");
}
}شرح الكود
- النسخة الأولى: كل سطر
newهو قرار hard-coded. أي تغيير في طريقة بناء الـ repository يضطرك تعدل OrderService. - النسخة التانية: الـ class بقى بيعتمد على abstractions (
IOrderRepository,IEmailSender) مش على implementations. ده مبدأ الـ Dependency Inversion من SOLID. - الـ constructor هو «العقد»: أي حد عايز OrderService لازم يديه الاتنين. وده بيخلي الـ dependencies ظاهرة وصريحة بدل ما تكون مخفية جوه الـ methods.
- في الـ unit test تقدر تمرر fake implementations من غير أي container (هنشوفها في قسم Testing).
الـ DI هو اللي بيخلي تبديل implementation (Redis بدل MemoryCache، Stripe بدل PayPal) تعديل سطر واحد في الـ registration بدل تعديل 30 class. وهو كمان اللي بيخلي الـ framework نفسه (Logging, Options, HttpClientFactory, EF Core) يتركب جوه تطبيقك بنفس الطريقة.
الـ Container من جوه: Registration ثم Resolution
الـ DI Container في ASP.NET Core بيشتغل على مرحلتين منفصلتين تماماً: (1) Registration بتقول فيها للـ container «لما حد يطلب X ادّيله Y بالـ lifetime ده»، و (2) Resolution وهي اللحظة اللي الـ container فعلاً بيبني فيها الـ object graph.
الـ Registration: ServiceDescriptor
كل سطر builder.Services.AddXxx بيضيف ServiceDescriptor للـ IServiceCollection. الـ descriptor فيه 3 معلومات: ServiceType (اللي الناس هتطلبه، غالباً interface)، ImplementationType أو factory أو instance (اللي هيتبني فعلاً)، و Lifetime.
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();شرح السطور المهمة
WebApplication.CreateBuilderبيجهزbuilder.Servicesوفيه بالفعل مئات الـ registrations بتاعة الـ framework (Logging, Configuration, Routing…).- الصيغة
AddScoped<TService, TImplementation>()بتقول: لما حد يطلبIOrderRepositoryابنيSqlOrderRepositoryواحد لكل scope. - الـ factory delegate بتتنفذ وقت الـ resolve مش وقت الـ registration، و الـ
spهو الـ provider الحالي. استخدمها لما بناء الـ object محتاج منطق أو config. - الـ instance الجاهز (
new SmtpEmailSender(...)) هو دايماً Singleton، وبما إنك انت اللي أنشأته فالـ container مش مسؤول عن الـDisposeبتاعه. - بعد
Build()مبقاش ينفع تضيف registrations: الـ collection بتتحول لـ immutable provider.
Constructor Injection: إزاي الـ container يختار الـ constructor؟
الـ container بيشوف الـ constructors الـ public، ويختار اللي عنده أكبر عدد parameters يقدر يـ resolve كلهم. لو لقى constructor-ين ملهمش علاقة ببعض (ambiguity) هيرمي InvalidOperationException. كل parameter بيتعمله resolve بنفس الطريقة بشكل recursive، وده اللي بنسميه Object Graph.
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)
POST /orders بيوصل. الـ ASP.NET Core بيعمل scope جديد للـ request ده.OrderService svc. لقاه نوع مسجل في الـ container فبيطلب GetService(typeof(OrderService)) من scope الـ request.OrderService: محتاج IOrderRepository و IClock و ILogger<OrderService>.IClock Singleton: لو أول مرة، بيبني SystemClock ويخزنه في الـ root. غير كده بيرجّع الـ instance الموجود.IOrderRepository Scoped: بيبني SqlOrderRepository (وبيـ resolve الـ dependencies بتاعته بنفس الطريقة، زي AppDbContext) ويخزنه في الـ scope.ILogger<OrderService> مسجل بالـ open generic بتاع الـ framework، فبيتبني لنوع OrderService.OrderService، والـ endpoint بيشتغل.Dispose: كل IDisposable بناه الـ container جوه الـ scope بيتعمله Dispose.لو سجلت نفس الـ service type أكتر من مرة، الـ resolve العادي (GetService<T>) بيرجّع آخر registration (last one wins). وطلب IEnumerable<T> بيرجّع كلهم بنفس ترتيب التسجيل. وفيه TryAddScoped بتسجل بس لو مفيش registration قبل كده (مفيدة لما تكتب library).
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) { }الـ Lifetimes: Transient / Scoped / Singleton
الـ 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
مثال عملي يثبت الفرق
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 }
});المخرجات المتوقعة
| Call | transient.same | scoped.same | singleton.same | الـ Guid بين الـ requests |
|---|---|---|---|---|
| GET /ids (request 1) | false | true | true | — |
| GET /ids (request 2) | false | true | true | scoped Guid اتغير، singleton Guid نفسه |
- الـ constructor بتاع كل class بيولّد
Guidجديد، فالـ Guid هو «بصمة» الـ instance. - الـ endpoint طلب كل نوع مرتين عشان نقارن: لو الـ Guid واحد يبقى نفس الـ instance.
- Transient: مرتين resolve = مرتين constructor = Guid مختلف.
- Scoped: الاتنين في نفس الـ scope فاتبنى مرة واحدة والتاني خد الـ cached instance.
- 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) أثبت إن ده مشكلة |
الـ service مسموح يعتمد على service عمرها أطول أو تساوي عمره فقط. Singleton ← Singleton ✅ · Scoped ← Singleton ✅ · Transient ← أي حاجة ✅ · لكن Singleton ← Scoped ❌ (ده الـ Captive Dependency، القسم الجاي).
تحت الغطا: إزاي بيحصل الـ Resolve بالظبط؟
مش لازم تحفظ أسماء الـ 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)) مش مسؤوليته.
لما تشوف Unable to resolve service for type 'X' while attempting to activate 'Y' فده معناه إن الـ container وهو بيبني الـ graph لـ Y ملقاش registration لـ X. ابدأ من الـ constructor بتاع Y وشوف الـ dependency الناقصة بالاسم.
Captive Dependencies و Scope Validation
ده أخطر وأشهر خطأ في الـ DI. بيحصل لما service ليها عمر طويل (Singleton) تحتفظ بـ reference لـ service عمرها أقصر (Scoped). الـ dependency القصيرة بتبقى «محبوسة» (captive) جوه الـ Singleton وبتعيش أطول بكتير من اللي المفروض.
الكود الغلط
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.
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
});شرح
UseDefaultServiceProviderبيعدّلServiceProviderOptionsاللي بيُبنى بيها الـ provider.- مع
ValidateScopes = true: أي محاولة لـ resolve scoped service من الـ root provider أو من singleton بترمي exception. - مع
ValidateOnBuild = true:builder.Build()هيفشل لو في أي service مش قادر الـ container يبنيها (dependency ناقصة). - الـ trade-off: الـ startup أبطأ شوية، لكن بتكتشف الأخطاء قبل ما أي مستخدم يشوفها. فكّر في تفعيلها في الـ CI/integration tests على الأقل.
الحلول الصح
الحل 1: وافق بين الـ lifetimes
الأسهل غالباً: خلي ReportService نفسه Scoped. معظم الـ business services المفروض تبقى scoped أصلاً لأنها بتتعامل مع الـ DbContext.
الحل 2: افتح scope يدوي
لو لازم الـ service تبقى Singleton (مثلاً service بتتشغل في background) حقن IServiceScopeFactory وافتح scope لكل عملية (القسم الجاي).
IServiceScopeFactory و DI في الـ Background Services
الـ BackgroundService / IHostedService بيتسجل كـ Singleton وبيشتغل برّه أي HTTP request، فمفيش «scope» تلقائي. أي استخدام للـ DbContext أو أي scoped service جواه لازم يتم عن طريق scope تفتحه انت.
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>();شرح
IServiceScopeFactoryنفسه Singleton آمن، فينفع تتحقن في أي Singleton.CreateAsyncScope()بيرجعAsyncServiceScopeبنستخدمه معawait usingعشان الـ Dispose يشتغل صح (بما فيهاIAsyncDisposable).- من
scope.ServiceProviderبنطلب أي scoped service؛ كل اللي بيتعمل في نفس الـ scope بيشارك نفس الـ DbContext. - كل تكرار في الـ loop = unit of work جديد بـ DbContext جديد. ده بيحمي من تراكم الـ tracked entities.
ExecuteDeleteAsyncبيعملDELETEمباشر في الـ SQL من غير ما يحمل الـ entities في الذاكرة.
لو الـ Singleton محتاج DbContext بس، ممكن تسجل AddDbContextFactory<AppDbContext>() وتحقن IDbContextFactory<AppDbContext> وتستدعي CreateDbContext() لكل عملية، من غير ما تتعامل مع scopes يدوي.
الـ convention-based middleware بيتبني مرة واحدة (مثل Singleton). متحقنش scoped service في الـ constructor بتاعه. خليه parameter في InvokeAsync(HttpContext ctx, IScopedService s) وهيتحقن من scope الـ request.
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);
}
}الـ Options Pattern
بدل ما تقرا configuration["Smtp:Host"] بالـ string في كل مكان، بتربط section من الـ config بـ class عادي (POCO) وتحقنه. ده بيدّيك type safety و validation وإمكانية reload.
{
"Smtp": {
"Host": "smtp.company.com",
"Port": 587,
"From": "noreply@company.com"
}
}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 ... */ }
}شرح
Bindبيملا خصائصSmtpOptionsمن section الـSmtp(اسم الـ section مش حساس لحالة الأحرف).ValidateDataAnnotationsبيطبق الـ attributes، وValidateOnStartبيخلي التحقق يحصل وقت بدء التطبيق مش عند أول استخدام.- بنحقن
IOptions<SmtpOptions>مشSmtpOptionsمباشرة، و.Valueبيرجّع النسخة المربوطة.
أي interface أستخدم؟
| Interface | Lifetime | بيشوف تغيير الـ config؟ | استخدمه لما… |
|---|---|---|---|
IOptions<T> | Singleton | لا (قيمة ثابتة بعد أول قراءة) | الإعدادات ثابتة طول تشغيل التطبيق |
IOptionsSnapshot<T> | Scoped | نعم، مرة لكل request | عايز config متحدث بين الـ requests (مينفعش يتحقن في Singleton) |
IOptionsMonitor<T> | Singleton | نعم، مع OnChange notifications | Singletons / background services محتاجة تشوف التغيير |
لو حاولت تحقن IOptionsSnapshot<T> (Scoped) في Singleton هتواجه نفس مشكلة الـ lifetimes. للـ singletons استخدم IOptionsMonitor<T>. وكمان لو عملت Configure<T> بـ dependencies من الـ DI، استخدم singleton services فقط جواها (متستخدمش DbContext).
Open Generics و Keyed Services
Open Generics
بدل ما تسجل IRepository<Order> و IRepository<Customer> و… كل واحد لوحده، بتسجل النوع المفتوح مرة واحدة والـ container بيقفله (closes it) تلقائياً وقت الـ resolve. ده نفس الـ trick اللي بيخلي ILogger<T> يشتغل لأي T.
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>typeof(IRepository<>)(الأقواس الفاضية) بتعني open generic type definition.- لما
CustomerServiceيطلبIRepository<Customer>الـ container بيبنيEfRepository<Customer>ويحقنه فيهAppDbContextالمناسب. - تحذير تصميمي: الـ generic repository فوق EF Core غالباً abstraction زيادة لأن
DbContextنفسه هو Repository و Unit of Work (شوف قسم «امتى متضيفش abstraction»).
Keyed Services
لما يكون عندك أكتر من implementation لنفس الـ interface وعايز تختار بينهم بالاسم، من .NET 8 فيه Keyed Services: بتسجل بـ key وبتطلب بنفس الـ key.
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");AddKeyedSingleton<TService, TImpl>(key)بيسجل الـ implementation تحت الـ key (الـ key object، غالباً string أو enum).[FromKeyedServices("local")]على الـ parameter بيقول للـ container أي registration يستخدم.- الـ registration العادي (من غير key) والـ keyed بيعيشوا جنب بعض ومبيتداخلوش.
- استخدمها بحذر: لو لقيت نفسك بتختار الـ implementation بالـ key في كل مكان، ممكن تكون محتاج strategy/factory صريح.
الاختبار مع الـ DI
أكبر فايدة عملية للـ DI هي الاختبار. فيه مستويين: unit tests من غير container أصلاً، و integration tests بتشغل التطبيق كله وتبدّل services معينة.
1) Unit test: من غير Container
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);
}
}- لأن
OrderServiceبياخد dependencies في الـ constructor، نقدر نعملnew OrderService(...)بـ fakes بسيطة. - الـ
FakeClockبيخلي الوقت deterministic؛ بدونIClockالاختبار ده مستحيل يبقى مضمون. NullLogger<T>.Instanceجاي منMicrosoft.Extensions.Logging.Abstractions.- القاعدة: unit test الـ class مباشرة، متبنيش container في الـ unit tests.
2) Integration test: تبديل service داخل التطبيق
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);
}
}WebApplicationFactory<Program>بيشغل التطبيق الحقيقي in-memory (محتاجpublic partial class Program {}لو بتستخدم top-level statements).ConfigureTestServicesبيشتغل بعد registrations التطبيق، فبيقدر يستبدلها.RemoveAll<T>بتشيل كل الـ registrations القديمة قبل ما تضيف الـ fake، عشان متبقاش عندك اتنين.- الفحص الـ end-to-end بيتم عن طريق
HttpClientبيتكلم مع الـ TestServer.
قرارات التصميم: Composition Root، Service Locator، وامتى متضيفش Abstraction
Composition Root
هو المكان الواحد اللي بتجمع فيه كل الـ registrations وبتعرف فيه الـ object graph، وفي ASP.NET Core هو Program.cs (أو extension methods منظمة بتتنادى منه). الانضباط ده يعني: الـ container بيتعرف فقط عند الـ startup، وباقي الكود بيستقبل dependencies من غير ما يعرف إن فيه container أصلاً.
// 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 محتاج إيه، فالاختبار صعب والأخطاء بتظهر وقت التشغيل مش وقت البناء.
// ❌ 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) { /* ... */ }
}داخل الـ 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بدون سبب).
Scrutor و Factory Delegates (Func<T>)
Scrutor: Assembly Scanning و Decoration
الـ built-in container بسيط ومفيهوش scanning ولا decoration. Scrutor هي مكتبة طرف تالت (NuGet package اسمها Scrutor) بتضيف extension methods على IServiceCollection للحاجتين دول.
// 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);
}Scanبيفحص الـ assembly بالـ reflection وقت الـ startup ويسجل الـ classes اللي تطابق الشرط، فمتحتاجش تكتب سطر لكل service.Decorate<TService, TDecorator>بيغيّر الـ registration الموجودة: لما حد يطلبIOrderRepositoryيرجّعلهCachedOrderRepositoryاللي جواه الـSqlOrderRepositoryالأصلي.- الـ decorator بيستقبل الـ inner في constructor بتاعه، فنفس مبدأ الـ DI بيتطبق.
- Trade-off: scanning بيخبي أي class اتسجل ومنين، وده بيصعب الـ debugging. استخدمه بشروط محددة وواضحة، مش
AddClasses()على كل حاجة.
Factory Delegates: Func<T> و Factories
الـ Microsoft DI container مبيدعمش Func<T> و Lazy<T> أوتوماتيك (عكس Autofac مثلاً). لو محتاج تنشئ instances جديدة وقت التشغيل أو تأجل الإنشاء، لازم تسجل الـ 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();
}- الـ lambda
() => sp.GetRequiredService<PdfReport>()بتتأخر لحد ما حد يستدعيها، فكل استدعاء = resolve جديد. - تحذير: الـ factory اللي مسجلة Singleton وبتـ capture الـ
sp(root) هتعمل resolve لـ scoped services من الـ root وده خطأ. خلي الـ factory تـ resolve بس transient/singleton، أو سجلها Scoped. - لو العدد قليل ومعروف، Keyed Services أنظف. استخدم الـ factory لما الاختيار بيعتمد على قيمة runtime حقيقية.
أخطاء شائعة وإزاي تكتشفها
| الخطأ | العَرَض | السبب | الحل |
|---|---|---|---|
| Singleton بيحقن Scoped/DbContext | Cannot consume scoped service… أو second operation started on this context | Captive dependency | غيّر الـ lifetime، أو IServiceScopeFactory، أو IDbContextFactory |
| نسيان تسجيل service | Unable 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 / root | Memory leak بيكبر مع الوقت | الـ container بيتتبع كل disposable transient لحد ما الـ scope يخلص (والـ root scope مبيخلصش إلا بإغلاق التطبيق) | خليه Scoped، أو افتح scope قصير العمر |
| Constructor بيحتاج 8-10 dependencies | صعب الاختبار والقراءة | الـ class بيعمل حاجات كتير (Single Responsibility) | قسّمه لـ classes أصغر؛ متخبيش المشكلة بـ IServiceProvider |
| Scoped service في constructor بتاع Middleware | Exception أو state مشترك بين requests | الـ middleware convention بيتبني مرة واحدة | حطه parameter في InvokeAsync |
| Resolve جوه loop ساخنة | ضغط على الـ GC وبطء | بتعمل allocations لكل transient | resolve مرة بره الـ loop |
إزاي تـ debug؟
- اقرا رسالة الـ exception من الآخر: بتقولك مين بيحاول يبني مين بالترتيب (
…while attempting to activate 'X'). - فعّل
ValidateScopesوValidateOnBuildفي الـ Development (مفعّلين افتراضياً) وفي الـ integration tests. - لو سلوك غريب في state: اتأكد من الـ lifetime، وتأكد إن مفيش service Singleton بتحتفظ بـ mutable state من غير
lock.
الأداء والمفاضلات
- 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 / Lamar | Features أكتر (modules, decorators, Func/Lazy, property injection) | تعقيد زيادة وتبعية خارجية؛ متحتاجهوش غالباً |
| Manual DI ("Pure DI") | أبسط حاجة ممكنة، compile-time safety كامل | الـ composition root بيكبر ومبيتكاملش مع الـ framework |
Knowledge Check
أهم النقاط
- الـ 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>.
قراءة كود
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.
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 صريح أفضل.
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
التوثيق الرسمي — Official documentation
مصادر تعليمية ومتقدمة — Third-party & advanced reading
خريطة التغطية: 17 عنصر من الـ Roadmap ومكان شرحه في الدرس
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.