LINQ مش مجرد Syntax مختصرة
LINQ اختصار Language Integrated Query: مجموعة operators موحدة بتسمحلك تصف عملية على sequence من البيانات باستخدام C#، سواء البيانات موجودة في memory أو جاية من provider خارجي زي EF Core. أهم فكرة: LINQ غالبًا بتوصف query، مش بالضرورة تنفذها فورًا. طريقة التنفيذ بتعتمد على نوع المصدر والـ operator واللحظة اللي بتطلب فيها النتيجة.
تخيل عندك قائمة Products. ممكن تعمل Where لاختيار المنتجات النشطة، ثم Select لاستخراج الاسم والسعر. في LINQ to Objects، الـ operators بتتنفذ على objects داخل process. في EF Core، نفس الشكل ممكن يتحول إلى SQL ويروح لقاعدة البيانات. التشابه في syntax لا يعني تشابه مكان التنفيذ أو التكلفة.
في الشغل الاحترافي، اسأل قبل كل query: المصدر إيه؟ التنفيذ هيحصل فين؟ إمتى؟ كام row هيتنقل؟ وهل الـ operator قابل للترجمة للـ provider؟ الأربع أسئلة دول بيمنعوا نسبة كبيرة من مشاكل LINQ و EF Core.
Operators الأساسية: Where و Select و SelectMany
Where بتفلتر العناصر وبتحافظ على نوع العنصر الأصلي. Select بتعمل projection: كل عنصر يتحول لقيمة أو object جديد. SelectMany بتسطح nested sequences: لو كل Customer عنده Orders، النتيجة تبقى sequence واحدة من الطلبات بدل sequence من collections.
var activeProducts = products
.Where(p => p.IsActive && p.Stock > 0)
.Select(p => new ProductSummary(p.Id, p.Name, p.Price));
// Result type: IEnumerable<ProductSummary>
public sealed record ProductSummary(int Id, string Name, decimal Price);اقرأ الـ pipeline من اليسار لليمين
productsهو المصدر.Whereلا ينشئ Product جديدًا؛ يمرر العناصر المطابقة فقط.Selectيحول كل Product إلى ProductSummary، وده يقلل البيانات اللي بتخرج من الطبقة.- نوع النتيجة يتغير من sequence of Product إلى sequence of ProductSummary.
var lines = customers.SelectMany(
customer => customer.Orders,
(customer, order) => new
{
CustomerName = customer.Name,
OrderId = order.Id,
order.Total
});الـ overload الثاني من SelectMany بيديك العنصر الخارجي والداخلي معًا. ده مفيد لما تحتاج بيانات Customer مع كل Order. في SQL غالبًا المعنى قريب من JOIN، لكن الترجمة الدقيقة تعتمد على شكل التعبير والـ provider.
اعمل Projection للحقول اللي محتاجها بدل ما ترجع Entity كاملة ثم تحولها بعد كده. ده يقلل نقل البيانات، ويقلل coupling مع persistence model، ويساعد على منع over-fetching.
اختبارات الوجود والشرط: Any و All
Any بتجاوب: هل يوجد عنصر واحد على الأقل يحقق الشرط؟ و All بتجاوب: هل كل العناصر تحقق الشرط؟ الاتنين بيرجعوا bool، وفي LINQ to Objects ممكن يوقفوا البحث أول ما يعرفوا النتيجة (short-circuit). في EF Core غالبًا Any تتحول إلى SQL EXISTS، وده عادة أفضل من تحميل كل الصفوف لمجرد معرفة وجود واحد.
bool hasOutOfStock = products.Any(p => p.Stock == 0);
bool allPricesValid = products.All(p => p.Price > 0);
// Database query: ask the database, do not load all orders.
bool hasPending = await db.Orders
.AnyAsync(o => o.CustomerId == customerId &&
o.Status == OrderStatus.Pending,
cancellationToken);خلي بالك من All على sequence فاضية: النتيجة true حسب منطق universal quantification (مفيش عنصر خالف الشرط). لو business rule بتقول لازم يكون فيه عنصر واحد على الأقل وكلهم يحققوا الشرط، اكتب الشرطين صراحة: items.Any() && items.All(...).
First و Single واختلاف معنى الاستثناء
اختيار operator هنا مش تفضيل شخصي؛ ده إعلان عن cardinality المتوقعة من الداتا:
First: عايز أول عنصر، ويرمي exception لو مفيش.FirstOrDefault: عايز أول عنصر إن وجد، وإلا default (غالبًا null للـ reference type).Single: متوقع عنصر واحد بالضبط؛ صفر أو أكثر من واحد خطأ.SingleOrDefault: متوقع صفر أو واحد؛ وجود أكثر من واحد خطأ.
// Email is protected by a UNIQUE database index.
var user = await db.Users
.SingleOrDefaultAsync(x => x.Email == normalizedEmail, ct);
if (user is null)
return Results.NotFound();
// A feed has many rows; newest item is enough.
var latest = await db.Notifications
.Where(x => x.UserId == userId)
.OrderByDescending(x => x.CreatedAt)
.FirstOrDefaultAsync(ct);لو بتستخدم First من غير OrderBy، فأنت لم تحدد معنى «الأول». قواعد البيانات مش ملزمة ترجع rows بترتيب ثابت من غير ORDER BY. ولو بتستخدم Single على Email، لازم كمان تحمي invariant في database بـ UNIQUE constraint/index؛ validation في التطبيق وحده مش كفاية مع concurrent requests.
Grouping و Join و GroupJoin
GroupBy بتقسم العناصر لمجموعات حسب key. في الذاكرة ممكن ينتج IGrouping<TKey,TElement>. في relational database، مش كل شكل GroupBy بيتترجم لنفس البنية؛ الشكل الأكثر وضوحًا للـ SQL هو grouping مع aggregates مثل Count و Sum و Average.
var salesByStatus = await db.Orders
.Where(o => o.CreatedAt >= from && o.CreatedAt < to)
.GroupBy(o => o.Status)
.Select(g => new
{
Status = g.Key,
OrdersCount = g.Count(),
Revenue = g.Sum(o => o.Total)
})
.ToListAsync(ct);الاستعلام ده يسمح للـ database تعمل grouping وتجميع وترجع صف واحد لكل status، بدل ما تنقل كل Orders للـ application وتحسب بنفسك. أما لو عملت ToListAsync قبل GroupBy فأنت نقلت كل البيانات أولًا وغيّرت مكان التنفيذ.
var query =
from order in db.Orders
join customer in db.Customers
on order.CustomerId equals customer.Id
select new { order.Id, Customer = customer.Name, order.Total };
// GroupJoin: one customer with a grouped sequence of orders.
var customerOrders = db.Customers.GroupJoin(
db.Orders,
c => c.Id,
o => o.CustomerId,
(customer, orders) => new { customer.Name, Orders = orders });الـ inner Join بيرجع المطابق فقط. لو محتاج customers حتى لو معندهمش orders، استخدم left join pattern المناسب للـ provider أو navigation projection. GroupJoin بيجمع related rows لكل outer row، لكنه مش بديل آلي عن كل أشكال SQL joins؛ افحص SQL الناتج.
Ordering و Distinct و Aggregate
OrderBy يبدأ ترتيب جديد، و ThenBy يضيف مستوى ترتيب ثانوي. استدعاء OrderBy مرة ثانية لا يكمل الأول؛ هو يعيد تعريف primary ordering. لازم تضيف tie-breaker ثابت لو هتستخدم Pagination، وغالبًا المفتاح الأساسي مناسب.
var pageQuery = db.Products
.OrderByDescending(p => p.CreatedAt)
.ThenBy(p => p.Id);Distinct بيزيل التكرار وفق equality semantics للنوع. مع objects مخصصة، افهم هل equality مبني على reference أو value، وهل محتاج comparer. في EF Core غالبًا يتحول إلى DISTINCT لكن قد يكون مكلفًا، فلا تستخدمه لإخفاء join غلط أو duplicate rows من تصميم query سيئ.
Aggregate عملية fold: تبدأ accumulator ثم تحدثه مع كل عنصر. استخدم Sum/Count/Min/Max للعمليات المعروفة؛ Aggregate مناسب لمنطق مخصص، لكن مش كل accumulator قابل للترجمة إلى SQL.
var sentence = words.Aggregate(
seed: new StringBuilder(),
func: (builder, word) =>
{
if (builder.Length > 0) builder.Append(' ');
return builder.Append(word);
},
resultSelector: builder => builder.ToString());لاحظ إن الـ seed هنا مهم: مع sequence فاضية هترجع string فاضية. أما overload من غير seed فممكن يرمي exception على sequence فاضية، وده لازم يدخل في حساباتك.
Deferred Execution مقابل Immediate Execution
معظم operators اللي بترجع sequence زي Where و Select و OrderBy بتبني query وتؤجل التنفيذ. التنفيذ يبدأ لما تعمل enumeration: foreach أو ToList أو ToArray أو operator محتاج scalar result زي Count و Any. لكن في تفاصيل: OrderBy deferred من ناحية وقت البداية، لكنه يحتاج غالبًا يقرأ المصدر كله قبل ما يقدر يطلع أول عنصر مرتب.
var numbers = new List<int> { 1, 2, 3 };
var query = numbers.Where(n => n > 1); // No iteration yet.
numbers.Add(4); // Query sees the updated source.
foreach (var number in query)
Console.WriteLine(number);
// Output:
// 2
// 3
// 4لو كررت enumeration، الـ query غالبًا هيتنفذ من جديد. مع LINQ to Objects ده يعني إعادة iteration وربما إعادة حساب expensive predicate. مع EF Core، كل enumeration لـ IQueryable ممكن يعمل round-trip جديد إلى database. لو محتاج snapshot ثابت، materialize مرة واحدة بوعي.
var active = await db.Products
.Where(p => p.IsActive)
.Select(p => new ProductSummary(p.Id, p.Name, p.Price))
.ToListAsync(ct);
var count = active.Count; // In memory.
var expensive = active.Where(IsExpensive).ToList();الـ materialization مش مجاني: بيستهلك memory، وبيفصل النتيجة عن أحدث تغييرات database بعد لحظة القراءة. استخدمه لما تحتاج snapshot أو إعادة استخدام محلية، مش كعادة تلقائية بعد كل operator.
IEnumerable vs IQueryable: الفرق اللي بيغير مكان التنفيذ
IEnumerable<T> abstraction للـ iteration. الـ LINQ operators عليه غالبًا تستقبل Func<T,bool> وتتنفذ في process. IQueryable<T> بيمثل query قابل للوصف عبر Expression<Func<T,bool>> مع provider مسؤول عن تفسير التعبير. EF Core provider بيحوّل expression tree إلى SQL مناسب.
Func<Product, bool> inMemoryRule = p => p.Price > 100;
Expression<Func<Product, bool>> queryRule = p => p.Price > 100;
IEnumerable<Product> memory = products.Where(inMemoryRule);
IQueryable<Product> database = db.Products.Where(queryRule);الـ delegate هو كود قابل للتنفيذ مباشرة. الـ expression tree هي بنية بيانات تصف الكود: node للمقارنة، node للخاصية، constant، وهكذا. الـ provider يقدر يحللها ويترجم الجزء المعروف. ده سبب إنك لا تستطيع تمرير أي C# method للـ EF وتتوقع إنها تتحول تلقائيًا إلى SQL.
لا تعمل AsEnumerable() أو ToList() مبكرًا لمجرد حل خطأ ترجمة من غير ما تفهم حجم البيانات. ده قد ينقل ملايين الصفوف للذاكرة ويحوّل filtering من database إلى application. حدد الجزء اللي لا يمكن ترجمته، وقلّص البيانات قبل الانتقال إلى client-side.
Deferred Execution و IQueryable vs IEnumerable
LINQ syntax واحدة لكن التنفيذ يختلف. IEnumerable<T> يمثل iteration على objects في الذاكرة، بينما IQueryable<T> يحمل expression tree يستهلكه provider مثل EF Core لتحويله إلى SQL. استدعاء Where على IQueryable يبني expression غالبًا ولا ينفذ query حتى materialization مثل ToListAsync أو iteration.
التحويل إلى AsEnumerable() يغيّر boundary: العمليات التالية تعمل في الذاكرة. لو وضعتها قبل filter كبير، قد تسحب ملايين الصفوف من database. حافظ على filtering, sorting, projection, pagination على provider قدر الإمكان، ثم materialize مرة واحدة عند boundary واضحة.
IQueryable<Product> query = db.Products
.Where(p => p.IsActive); // expression is composed
query = query.Where(p => p.Price >= minPrice);
var sql = query.ToQueryString(); // inspect generated SQL
var rows = await query
.Select(p => new { p.Id, p.Name, p.Price })
.ToListAsync(ct); // execution/materializationلا ترجع IQueryable من service boundary عامة إذا كان ذلك يسمح للمستهلك بتغيير query semantics أو يربط الطبقات بـ EF. أحيانًا يكون مفيدًا داخل infrastructure composition، لكن غالبًا الأفضل أن ترجع DTO أو نتيجة use case بعد تنفيذ الاستعلام.
SQL Translation: إزاي تراجع اللي EF Core هيبعته؟
EF Core مش بيترجم كل C# إلى SQL؛ هو بيدعم مجموعة expressions حسب provider والإصدار. لو expression غير قابل للترجمة في جزء لازم ينفذ على السيرفر، EF Core الحديث غالبًا يرمي exception بدل ما يسحب كل الجدول silently. بعض التعبيرات في top-level projection ممكن تتنفذ client-side، فافهم مكانها.
var query = db.Products
.Where(p => p.IsActive && p.Price >= minPrice)
.OrderBy(p => p.Name)
.Select(p => new { p.Id, p.Name, p.Price });
Console.WriteLine(query.ToQueryString());راجع SQL من حيث: الأعمدة المختارة، predicate، joins، parameterization، ORDER BY، pagination، وهل فيه function على column تمنع index seek. لا تعتمد على قراءة LINQ وحدها للحكم على الأداء. واستخدم logging أو database profiler في بيئة آمنة لمراجعة commands الفعلية ووقت التنفيذ.
static bool IsPremiumName(string name) => name.StartsWith("Pro-");
// This custom method is not automatically translated to SQL.
// Prefer expressing supported operations in the query:
var products = await db.Products
.Where(p => p.Name.StartsWith("Pro-"))
.ToListAsync(ct);Parameterization مهمة للأمان وإعادة استخدام execution plans. تجنب بناء SQL بدمج user input في النص. EF Core parameterizes values في LINQ المعتاد، لكن raw SQL لازم تستخدم API parameterized وتراجع identifiers الديناميكية بشكل منفصل.
Pagination و Skip/Take
Skip و Take بيعبّروا عن pagination شائعة. لازم يكون فيه ترتيب deterministic؛ وإلا ممكن نفس الصف يظهر في صفحتين أو يختفي بين طلبين. Offset pagination سهلة للقفز إلى page رقم N، لكنها قد تبقى مكلفة مع offset كبير لأن قاعدة البيانات قد تحتاج تتخطى عددًا كبيرًا من الصفوف.
var pageSize = Math.Clamp(request.PageSize, 1, 100);
var pageNumber = Math.Max(request.PageNumber, 1);
var items = await db.Products
.AsNoTracking()
.Where(p => p.IsActive)
.OrderBy(p => p.Id)
.Skip((pageNumber - 1) * pageSize)
.Take(pageSize)
.Select(p => new ProductSummary(p.Id, p.Name, p.Price))
.ToListAsync(ct);للقوائم الكبيرة والمتغيرة باستمرار، فكر في Keyset/Seek pagination: بدل offset، ابعت آخر key شوفتها، واطلب الصفوف اللي بعدها. لازم ترتيبك يكون فريدًا أو تضيف tie-breaker.
var nextPage = await db.Orders
.Where(o => o.CreatedAt > cursor.CreatedAt ||
(o.CreatedAt == cursor.CreatedAt && o.Id > cursor.Id))
.OrderBy(o => o.CreatedAt)
.ThenBy(o => o.Id)
.Take(pageSize)
.Select(o => new OrderRow(o.Id, o.CreatedAt, o.Total))
.ToListAsync(ct);الـ index المناسب غالبًا يبدأ بأعمدة الفلترة/الترتيب المتوافقة مع query، لكن الترتيب الدقيق يعتمد على cardinality وخطة التنفيذ. لا تضف index عشوائيًا من غير قراءة execution plan.
أخطاء LINQ الشائعة وكيف تشخّصها
- N+1: query رئيسية ثم query لكل عنصر بسبب lazy loading أو loop يستدعي navigation. الحل غالبًا projection أو Include محسوب أو batch query.
- Premature materialization: تنفيذ
ToListقبل filtering/grouping فينقل بيانات أكثر من اللازم. - Repeated enumeration: نفس query يتعد مرتين، وقد يعيد DB call أو يعيد حساب مصدر مكلف.
- Missing ordering: استخدام Skip/Take أو First من غير ترتيب ثابت.
- Client-side work: تحويل إلى IEnumerable مبكرًا ثم تنفيذ predicate في الذاكرة.
- Wrong cardinality operator: استخدام First رغم أن business rule تتطلب uniqueness، أو Single على بيانات غير محمية بقيد فريد.
- Huge object graphs: Include متداخل يعيد بيانات مكررة كثيرة؛ فكر في projection أو split query بعد قياس.
- String comparison mismatch: اختلاف collation/case sensitivity بين .NET و database قد يغير semantics.
// Risky pattern: one query for customers, then one per customer.
var customers = await db.Customers.ToListAsync(ct);
foreach (var customer in customers)
{
var count = await db.Orders.CountAsync(
o => o.CustomerId == customer.Id, ct);
}
// Better: let the database aggregate in one query.
var summaries = await db.Customers
.Select(c => new CustomerSummary(
c.Id, c.Name, c.Orders.Count()))
.ToListAsync(ct);الأفضل مش دايمًا «query واحدة» بأي ثمن. Query ضخمة مع joins متعددة ممكن تعمل cartesian explosion. قارن عدد round trips وحجم payload وعدد الصفوف المكررة و execution time. استخدم split query أو عدة queries محسوبة لو ده يقلل التكلفة الكلية ويحافظ على consistency المطلوبة.
اختبار LINQ وفحص صحة الاستعلام
اختبار LINQ to Objects سهل، لكن اختبار LINQ to Entities لازم يراعي إن provider هو اللي بيحدد الترجمة والـ SQL semantics. EF Core InMemory provider مش بديل حقيقي لـ SQL Server؛ لا يختبر relational constraints ولا translation ولا transactions بنفس الطريقة. اختبر الاستعلامات الحرجة على نفس نوع database provider، غالبًا عبر test database أو container.
[Fact]
public async Task Search_returns_only_active_products_in_price_order()
{
await using var db = CreateSqlServerTestContext();
await SeedProducts(db);
var result = await new ProductQueries(db)
.SearchAsync(minPrice: 50m, ct: CancellationToken.None);
Assert.All(result, item => Assert.True(item.Price >= 50m));
Assert.Equal(result.OrderBy(x => x.Price).Select(x => x.Id),
result.Select(x => x.Id));
}اختبر edge cases: مصدر فارغ، عنصر واحد، duplicate keys، null values، حدود pagination، قيم تاريخ على boundary، وعدد records كبير. افحص SQL للـ queries الحساسة، وقِس زمنها و logical reads على بيانات قريبة من الواقع.
اختيار Operator حسب السؤال
| السؤال | Operator | ملاحظة |
|---|---|---|
| هل يوجد عنصر؟ | Any | أفضل من تحميل القائمة لمجرد الوجود |
| أريد عنصرًا واحدًا مع ضمان uniqueness | Single | احمِ uniqueness بقيد في DB |
| أريد أول عنصر حسب ترتيب محدد | OrderBy + First | حدد ترتيبًا deterministic |
| أريد DTO أو أعمدة محددة | Select | Projection مبكر على server |
| أريد تجميعًا | GroupBy + aggregates | تأكد من SQL translation |
| أريد snapshot محلية | ToList | استخدمها بوعي للذاكرة |
| أريد صفحات عميقة | Keyset pagination | cursor + stable unique order |
خلاصة الدرس: LINQ لغة لوصف الاستعلام، والـ provider هو اللي يحدد التنفيذ. افهم نوع المصدر، وتوقيت materialization، والـ expression tree، ثم راجع SQL والـ execution plan لما يكون المصدر database. ما تحكمش على performance من شكل C# وحده.
اختبر فهمك
لو كتبت Where على IQueryable ثم استدعيت ToListAsync، فين غالبًا بيتنفذ الـ predicate؟
ما الفرق الأساسي بين Func و Expression<Func>؟
لماذا OrderBy مطلوب قبل Skip/Take؟
هل ToList مجرد تحسين أداء؟
متى تستخدم Single بدل First؟
LINQ Provider Boundary: ما الذي يترجم SQL وما الذي ينفذ في Memory؟
IQueryable<T> يحمل expression tree يستطيع provider ترجمته؛ IEnumerable<T> يصف enumeration في .NET. استدعاء AsEnumerable() ينقل العمليات اللاحقة إلى client-side، بينما ToListAsync() ينفذ query ويحمّل النتائج. بعض .NET methods لا يمكن ترجمتها إلى SQL؛ EF Core الحديث غالبًا يرمي exception إذا كانت client evaluation في filter غير قابلة للترجمة، بدل تحميل الجدول كله بصمت.
ضع projection/filter/order/page قبل materialization. تجنب ToList() المبكر ثم Where في memory. لا تستخدم Count() ثم ToList() إذا تحتاج فقط page؛ احسب total عند الحاجة بوعي لأن count query إضافية. تأكد من stable ordering مع unique tie-breaker حتى pagination لا تتكرر أو تفقد records عند تساوي sort key.
Translation Pitfalls و N+1 و Pagination
مش كل C# expression قابل للترجمة إلى SQL. التعبير الذي يعمل على List في unit test قد يفشل على SQL Server provider. اختبر query المهمة على نفس provider المستخدم في الإنتاج. كذلك، استدعاء navigation داخل loop بعد جلب parents قد يصنع N+1 إذا كان Lazy Loading مفعلًا؛ الأفضل projection أو Include مدروس أو explicit batch query.
Pagination بـ Skip/Take مناسبة للصفحات الصغيرة والمتوسطة، لكن offset الكبير يجعل المحرك يتخطى صفوفًا كثيرة. Keyset pagination تستخدم آخر مفتاح شوهد لتبدأ بعده، وهي أفضل للتمرير المستمر على datasets كبيرة مع index مناسب.
// Keyset pagination on a unique, indexed ordering:
var nextPage = await db.Orders
.Where(o => o.CreatedAt < cursor.CreatedAt ||
(o.CreatedAt == cursor.CreatedAt && o.Id < cursor.Id))
.OrderByDescending(o => o.CreatedAt)
.ThenByDescending(o => o.Id)
.Take(pageSize)
.Select(o => new OrderRow(o.Id, o.CreatedAt, o.Total))
.ToListAsync(ct);الـ cursor يجب أن يحمل كل أعمدة الترتيب، وأن تكون المقارنة متوافقة مع sort direction. لو الترتيب CreatedAt DESC, Id DESC فلا تقارن Id وحده. ضع index مركبًا يطابق filter/order قدر الإمكان، واختبر الحالات عند تساوي timestamps.
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
خريطة التغطية: 19 عنصر من الـ Roadmap ومكان شرحه في الدرس
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.