الـ async / await والـ Task: النموذج الذهني الصحيح
الـ async مش معناها «شغّل الكود على Thread تاني». دي أهم فكرة لازم تثبتها قبل كتابة أي كود asynchronous. الهدف الأساسي هو إن العملية اللي بتنتظر I/O (زي HTTP أو Database أو File) ما تحجزش Thread طول فترة الانتظار. الـ Task بيمثل عملية هتنتهي في المستقبل، والـ await بيسمح للـ method توقف من غير ما توقف الـ Thread نفسه.
Synchronous wait
الـ Thread يبدأ العملية، وبعدها يفضل محجوز لحد ما النتيجة ترجع. في ASP.NET Core ده ممكن يقلل عدد requests اللي السيرفر يقدر يخدمها تحت الحمل.
Asynchronous wait
العملية تبدأ وترجع Task. لو لسه ما خلصتش، الـ method تحفظ حالتها وترجع للـ caller. لما العملية تكتمل، الـ continuation يكمل التنفيذ.
Parallel execution
ده مفهوم مختلف: أكتر من عملية CPU-bound بتتنفذ في نفس الوقت على أكتر من core. ممكن تعمل parallelism باستخدام Tasks، لكن مش كل async بيكون parallel.
من الـ Task إلى الـ State Machine
الـ Task مش Thread. هو object بيمثل completion: ممكن يكون مكتمل بالفعل، أو شغال، أو انتهى بخطأ، أو اتلغى. الـ Task<T> كمان بيحمل نتيجة من النوع T. لما تكتب async compiler بيحوّل الـ method إلى state machine تقريبًا: تحفظ local variables ومكان الاستكمال (state) وتربط continuation بالعملية المنتظرة.
using System.Net.Http.Json;
using var http = new HttpClient();
static async Task<string> LoadNameAsync(HttpClient client, int id)
{
var url = $"https://api.example.test/users/{id}";
UserDto? user = await client.GetFromJsonAsync<UserDto>(url);
return user?.Name ?? "Unknown";
}
// Start both network operations before awaiting either one.
Task<string> firstTask = LoadNameAsync(http, 10);
Task<string> secondTask = LoadNameAsync(http, 20);
string[] names = await Task.WhenAll(firstTask, secondTask);
Console.WriteLine(string.Join(", ", names));
public sealed record UserDto(string Name);شرح التنفيذ
GetFromJsonAsyncيبدأ HTTP request ويرجعTask<UserDto?>. العملية فيها I/O، لذلك مش محتاجة Thread يفضل واقف منتظر الرد.- أول استدعاء يبدأ الطلب الأول. لأننا لم نكتب
awaitبعده، الـ Task اتخزن فيfirstTaskوالكود كمل. - الاستدعاء الثاني يبدأ الطلب الثاني قبل ما ننتظر الأول؛ بالتالي العمليتان ممكن تتداخل مدتهما.
Task.WhenAllينتظر اكتمال الاثنين. لو أي Task فشل، الـ await يرمي exception، ولو نجحوا بيرجع النتائج بنفس ترتيب الـ Tasks الممررة.- الـ
usingعلىHttpClientهنا للتوضيح في برنامج صغير. في ASP.NET Core استخدمIHttpClientFactoryبدل إنشاء Client لكل request.
إمتى أستخدم Task.Run؟
Task.Run بيجدول delegate على ThreadPool، ولذلك مفيد غالبًا لشغل CPU-bound لما محتاج تنقله بعيدًا عن Thread الواجهة في desktop application. لكنه مش علاج للـ I/O. في ASP.NET Core، لفّ استدعاء قاعدة البيانات أو HTTP داخل Task.Run بيستهلك Thread إضافي من غير فايدة، وممكن يزود ضغط الـ ThreadPool.
// I/O-bound: call the asynchronous API directly.
UserDto? user = await http.GetFromJsonAsync<UserDto>(url, cancellationToken);
// CPU-bound: Task.Run can move expensive computation to a worker thread.
int[] sorted = await Task.Run(() =>
{
int[] copy = numbers.ToArray();
Array.Sort(copy);
return copy;
}, cancellationToken);القاعدة: I/O-bound = استخدم API غير متزامنة بطبيعتها. CPU-bound = قيّم هل تحتاج parallelism أو جدولة على ThreadPool، مع قياس أثر ذلك.
أخطاء async الشائعة
| النمط الخاطئ | المشكلة | البديل |
|---|---|---|
.Result / .Wait() | حجب Thread واحتمال deadlock في سياقات تلتقط SynchronizationContext. | استخدم await من أول call chain لآخره. |
async void | الـ caller لا يقدر ينتظر completion أو يلتقط exceptions بشكل طبيعي. | Task أو Task<T>، ما عدا event handlers. |
| نسيان await | fire-and-forget غير مراقب؛ exceptions وتوقيت التنفيذ يصبحان غير واضحين. | انتظر الـ Task أو سلّمه عمدًا لمكوّن مسؤول عن lifecycle. |
| Task.Run حول I/O | ThreadPool thread يظل منتظرًا بلا داعٍ. | استدعِ النسخة async الأصلية. |
صمّم الـ API بحيث تعيد Task عند تمثيل عملية غير متزامنة. لا تخترع Thread لكل عملية، ولا تحجب Thread لاسترجاع نتيجة الـ Task.
الـ CancellationToken: إلغاء تعاوني وليس زر إيقاف قسري
في التطبيقات الحقيقية، العملية قد تصبح بلا معنى قبل أن تنتهي: المستخدم قفل الصفحة، الـ HTTP request اتلغى، أو انتهت مهلة الاتصال. .NET يستخدم cooperative cancellation: مصدر الإلغاء يعلن طلب الإلغاء، وكل جزء من العملية يقرر كيف يستجيب له عند نقطة آمنة.
العناصر الأساسية
CancellationTokenSource: الجهة التي تطلب الإلغاء، ويمكنها إلغاء token يدويًا أو بعد timeout.CancellationToken: قيمة immutable تُمرر إلى العمليات لتراقب طلب الإلغاء.ThrowIfCancellationRequested(): طريقة شائعة للتحقق وإطلاقOperationCanceledException.CancellationToken.None: token لا يطلب الإلغاء.
public sealed class ReportService(HttpClient http, ILogger<ReportService> logger)
{
public async Task<string> DownloadReportAsync(
int reportId,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using var response = await http.GetAsync(
$"reports/{reportId}",
HttpCompletionOption.ResponseHeadersRead,
cancellationToken);
response.EnsureSuccessStatusCode();
string body = await response.Content.ReadAsStringAsync(cancellationToken);
logger.LogInformation("Downloaded report {ReportId}", reportId);
return body;
}
}
// At the call site:
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(8));
string report = await service.DownloadReportAsync(42, timeout.Token);Line-by-line
- استلام token من الـ caller يخلي الـ service مش مسؤولة عن إنشاء قرار الإلغاء؛ المسؤولية بتفضل عند orchestration layer.
- التحقق المبكر يمنع بدء شغل معروف إنه اتلغى بالفعل.
- تمرير token إلى
GetAsyncمهم: لو اكتفينا بفحصه قبل الطلب، مش هنقدر نطلب إلغاء الـ network operation بعد بدايتها. - تمريره إلى
ReadAsStringAsyncيمدد الإلغاء لمرحلة قراءة الـ body، مش مجرد انتظار الـ headers. - الـ
CancellationTokenSource(TimeSpan)يطلب الإلغاء بعد 8 ثوانٍ. الـ timeout هنا represented كـ cancellation؛ التطبيق يقدر يميز مصدر الإلغاء إذا احتاج سلوكًا مختلفًا.
ربط عمليات الإلغاء
using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
httpContext.RequestAborted,
timeoutCts.Token);
await reportService.GenerateAsync(linkedCts.Token);
if (timeoutCts.IsCancellationRequested && !httpContext.RequestAborted.IsCancellationRequested)
{
// The service timeout elapsed; map to an application-specific timeout response.
}في ASP.NET Core، HttpContext.RequestAborted يعبر عن إلغاء العميل للطلب. اربطه بالعمليات التابعة التي تدعم cancellation، مثل EF Core و HttpClient وعمليات القراءة والكتابة. لا تبتلع OperationCanceledException بشكل عشوائي؛ افهم هل الإلغاء متوقع، وهل السبب client disconnect أم service timeout.
Cancellation مش قتل Thread ولا rollback تلقائي. لو العملية عدّلت بيانات خارجية قبل الإلغاء، لازم تحدد هل تحتاج transaction أو compensation أو تصميم idempotent. العملية التي لا تفحص token لن تتوقف لمجرد أن token اتلغى.
Task مقابل ValueTask: تحسين متخصص وليس اختيار افتراضي
Task<T> مناسب لمعظم APIs غير المتزامنة. لكنه reference type؛ ولو API بتكمل synchronously في نسبة كبيرة من الاستدعاءات، إنشاء Task جديدة لكل نتيجة قد يضيف allocations. ValueTask<T> struct يقدر يحمل النتيجة مباشرة في حالات synchronous completion، أو يحمل Task عند الحاجة.
| المقارنة | Task<T> | ValueTask<T> |
|---|---|---|
| الشكل | Reference type | Value type wrapping result or Task-like source |
| استهلاك النتيجة | يمكن await أكثر من مرة عادةً | يجب التعامل معه كعملية await واحدة؛ لا تخزن/تكرر الاستهلاك دون فهم القيود |
| الـ composition | أوضح وأسهل مع WhenAll ومكتبات المهام | يتطلب أحيانًا تحويلًا إلى Task باستخدام AsTask |
| الاستخدام | الخيار الافتراضي | Hot path مثبت بالقياس وفيه sync completion متكرر |
using System.Collections.Concurrent;
public sealed class UserCache(IUserRepository repository)
{
private readonly ConcurrentDictionary<int, User> _cache = new();
public ValueTask<User?> GetAsync(int id, CancellationToken cancellationToken)
{
if (_cache.TryGetValue(id, out User? cached))
{
return ValueTask.FromResult<User?>(cached);
}
return new ValueTask<User?>(LoadAndCacheAsync(id, cancellationToken));
}
private async Task<User?> LoadAndCacheAsync(int id, CancellationToken cancellationToken)
{
User? user = await repository.FindAsync(id, cancellationToken);
if (user is not null) _cache[id] = user;
return user;
}
}الفكرة والـ trace
- لو القيمة موجودة في الـ cache،
ValueTask.FromResultيعيد النتيجة من غير إنشاء Task جديدة. - لو القيمة غير موجودة، الـ ValueTask يغلف الـ Task الناتجة من
LoadAndCacheAsync. - الـ caller يقدر يعمل
await cache.GetAsync(...)في الحالتين بنفس الطريقة. - الـ
ConcurrentDictionaryيحمي عمليات القراءة والكتابة الفردية. لكنه لا يمنع أن طلبين متزامنين لنفس المفتاح يحمّلا نفس المستخدم مرتين عند cache miss؛ لو منع تكرار التحميل مهم، استخدم نمطًا مثلLazy<Task<T>>أو primitive مناسب للـ async cache.
لا تحول كل Task<T> إلى ValueTask<T> على أمل أنها أسرع. الـ ValueTask أكبر وأكثر تعقيدًا في الاستهلاك، وقد يزيد تكلفة الـ caller. استخدمها عندما profiling يثبت أن allocation في synchronous completion تمثل مشكلة فعلية.
الـ IAsyncEnumerable و await foreach
الـ Task<List<T>> ينتظر لحد ما كل النتائج تتجمع في الذاكرة ثم يسلم القائمة مرة واحدة. لكن أحيانًا النتائج بتوصل تدريجيًا: صفحات API، records من مصدر بطيء، أو events. هنا IAsyncEnumerable<T> بيمثل stream، وكل عنصر ممكن يحتاج asynchronous wait قبل إنتاجه.
using System.Runtime.CompilerServices;
static async IAsyncEnumerable<int> ReadPagesAsync(
[EnumeratorCancellation] CancellationToken cancellationToken = default)
{
for (int page = 1; page <= 3; page++)
{
cancellationToken.ThrowIfCancellationRequested();
await Task.Delay(250, cancellationToken); // simulate network page fetch
yield return page;
}
}
await foreach (int page in ReadPagesAsync(cancellationToken)
.WithCancellation(cancellationToken))
{
Console.WriteLine($"Received page {page}");
}ماذا يحدث؟
async IAsyncEnumerable<int>تعلن asynchronous iterator بدل Task واحدة ترجع كل البيانات.yield returnينتج عنصرًا ويرجع التحكم للمستهلك؛ لا يحتاج تخزين كل العناصر في قائمة.[EnumeratorCancellation]يحدد token الذي يمرره المستهلك إلى iterator عند استهلاك stream.await foreachينتظر جلب العنصر التالي بشكل asynchronous. لو جلب الصفحة بطيء، المستهلك لا يحجز Thread لمجرد الانتظار.WithCancellationيمرر cancellation token إلى enumerator. استخدمه عند استهلاك streams من APIs لا تتحكم في توقيعها.
اختيار Stream أم Collection
| اختار | لما | انتبه إلى |
|---|---|---|
Task<List<T>> | عدد النتائج محدود، وتحتاج sorting أو random access أو إجمالي count. | الذاكرة ووقت أول نتيجة يتأخران حتى اكتمال التحميل. |
IAsyncEnumerable<T> | عدد كبير/غير معروف، أو النتائج تصل تدريجيًا. | المستهلك قد يتوقف مبكرًا؛ يجب دعم cancellation والتنظيف الصحيح للـ enumerator. |
الـ stream يقلل buffering عند المستهلك، لكنه لا يضمن أن كل الطبقات upstream لا تعمل buffering. افحص تنفيذ المصدر، وسياسة pagination، وحجم كل عنصر، وسلوك الإلغاء.
Threading والـ Concurrency والـ ThreadPool
الـ concurrency معناها وجود أعمال متعددة متداخلة زمنيًا، حتى لو لم تعمل في اللحظة نفسها. الـ parallelism هو تنفيذ فعلي متزامن على أكثر من core. المشكلة الهندسية تبدأ عندما تتشارك الأعمال في mutable state: ترتيب التنفيذ غير مضمون، ولذلك قد تظهر race conditions.
Concurrency
أكثر من operation نشطة، ويمكن أن تتقدم إحداها بينما الأخرى تنتظر. async I/O مثال شائع من غير الحاجة إلى Thread مخصص لكل operation.
Parallelism
أكثر من operation CPU-bound تنفذ في وقت واحد على cores متعددة. مفيد للحسابات المستقلة التي تستحق تكلفة الجدولة والمزامنة.
ThreadPool
مجموعة Threads يعاد استخدامها لتنفيذ work items. تقلل تكلفة إنشاء Thread في كل مرة، لكنها مورد محدود ويجب ألا نحجزها بعمليات انتظار طويلة بلا داعٍ.
Race condition: لماذا التحديث البسيط ليس آمنًا؟
public sealed class UnsafeCounter
{
private int _value;
public void Increment()
{
_value++; // read -> add -> write; not one atomic operation
}
public int Value => _value;
}
var counter = new UnsafeCounter();
Parallel.For(0, 100_000, _ => counter.Increment());
Console.WriteLine(counter.Value); // may be less than 100,000الـ _value++ ليست عملية ذرية: Thread A قد يقرأ 10، و Thread B يقرأ 10، ثم كل واحد يكتب 11؛ الزيادة الثانية تضيع. المشكلة مش في نوع int نفسه، بل في read-modify-write المركبة.
using System.Threading;
public sealed class SafeCounter
{
private int _value;
public void Increment() => Interlocked.Increment(ref _value);
public int Value => Volatile.Read(ref _value);
}Interlocked.Increment ينفذ read-modify-write بشكل ذري. استخدمه للعمليات البسيطة على متغير واحد. لما invariant يمتد على أكثر من متغير أو أكثر من خطوة، قد تحتاج lock.
public sealed class Inventory
{
private readonly object _gate = new();
private int _available;
public Inventory(int initialQuantity) => _available = initialQuantity;
public bool TryTake(int quantity)
{
if (quantity <= 0) throw new ArgumentOutOfRangeException(nameof(quantity));
lock (_gate)
{
if (_available < quantity) return false;
_available -= quantity;
return true;
}
}
}شرح الـ lock
- كل Instances من
Inventoryتملك نفس_gateالخاص بها. - الـ
lockيضمن دخول Thread واحد في المنطقة الحرجة على نفس object lock في الوقت نفسه. - فحص الكمية وتخفيضها داخل نفس المنطقة يحافظ على invariant: المخزون لا يصبح سالبًا بسبب طلبين متزامنين.
- الـ lock لا يحمي من كود آخر يعدل نفس البيانات من غير استخدام نفس lock؛ كل الأطراف لازم تتفق على آلية المزامنة.
اختيار أداة المزامنة
| الأداة | مناسبة لـ | تنبيه |
|---|---|---|
lock / Monitor | Critical section قصيرة ومتزامنة داخل process. | لا تعمل await داخل lock التقليدي. |
Interlocked | تحديث ذري بسيط لقيمة أو عداد. | لا يكفي لعدة خطوات مترابطة. |
SemaphoreSlim | تحديد عدد عمليات متزامنة، ويدعم WaitAsync. | تأكد من Release داخل finally. |
ConcurrentDictionary | عمليات متزامنة شائعة على dictionary. | العمليات المركبة على بيانات مرتبطة قد تحتاج تصميمًا إضافيًا. |
الـ deadlock ينتج عندما تنتظر مجموعة أعمال بعضها بعضًا في دورة مغلقة. أما ThreadPool starvation فيحدث عندما تكون Threads المتاحة محجوزة أو blocking، فلا تبدأ أعمال جديدة بسرعة كافية. تجنب sync-over-async، وقلل الأقفال المتداخلة، ولا تستدعِ network/database داخل lock، وقِس الـ ThreadPool تحت حمل واقعي.
System.Threading.Channels: Producer / Consumer
الـ Channel قناة FIFO آمنة بين producers و consumers. بدل ما producer ينادي consumer مباشرة، يكتب item في channel، والـ consumer يقرأه لاحقًا. الميزة المهمة أنها تدعم asynchronous waiting، وممكن تعمل bounded capacity لتطبيق backpressure: لما الطابور يتملي، المنتج ينتظر بدل ما يستهلك الذاكرة بلا حدود.
using System.Threading.Channels;
var channel = Channel.CreateBounded<int>(new BoundedChannelOptions(100)
{
FullMode = BoundedChannelFullMode.Wait,
SingleWriter = true,
SingleReader = false
});
async Task ProduceAsync(CancellationToken cancellationToken)
{
try
{
for (int item = 1; item <= 500; item++)
{
await channel.Writer.WriteAsync(item, cancellationToken);
}
}
finally
{
channel.Writer.TryComplete();
}
}
async Task ConsumeAsync(CancellationToken cancellationToken)
{
await foreach (int item in channel.Reader.ReadAllAsync(cancellationToken))
{
await ProcessAsync(item, cancellationToken);
}
}
async Task ProcessAsync(int item, CancellationToken cancellationToken)
{
await Task.Delay(10, cancellationToken);
Console.WriteLine($"Processed {item}");
}
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
Task producer = ProduceAsync(cts.Token);
Task[] consumers = Enumerable.Range(0, 3)
.Select(_ => ConsumeAsync(cts.Token))
.ToArray();
await Task.WhenAll(consumers.Prepend(producer));شرح الكود والتدفق
CreateBounded<int>(100)يحدد أن القناة لا تحتفظ بأكثر من 100 عنصر منتظر في الوضع الطبيعي.FullMode.WaitيجعلWriteAsyncينتظر عند الامتلاء. البدائل مثل DropOldest/DropNewest مناسبة فقط لو فقد بعض العناصر مقبول ومقصود.- المنتج يكتب 500 item، لكنه لا يضخهم كلهم في الذاكرة؛ عند بلوغ السعة ينتظر المستهلكين يفرغوا مساحة.
TryCompleteيخبر القارئ أنه لن تأتي عناصر جديدة. وضعه في finally يمنع consumer من الانتظار للأبد إذا انتهى producer بسبب خطأ، مع ملاحظة أن التطبيقات الأكثر تعقيدًا قد تمرر سبب الفشل إلىTryComplete(exception).- ثلاثة consumers يقرؤون من نفس channel. كل item يسحبه consumer واحد، وليس كلهم.
Task.WhenAllينتظر producer وكل consumers. الإلغاء يوقف العملية التعاونية، بينما completion ينهي stream طبيعيًا.
الـ Channel مفيد للـ in-process pipelines، buffering، background workers، وتهدئة burst traffic. لكنه ليس message broker دائمًا: العناصر في الذاكرة وقد تضيع عند إغلاق العملية. لو محتاج durability أو توزيع بين instances أو replay استخدم broker مثل RabbitMQ أو Azure Service Bus أو Kafka وفق المتطلبات.
Parallel و PLINQ: تشغيل الحسابات على أكثر من Core
لو عندك 100 ألف سجل وتحتاج تحسب score لكل واحد بشكل مستقل، ممكن تقسيم الشغل على cores متعددة. لكن parallelism له تكلفة: scheduling، synchronization، partitioning، ودمج النتائج. لو العملية صغيرة أو الذاكرة/الشبكة هي bottleneck، parallel قد يكون أبطأ.
using System.Collections.Concurrent;
var inputs = Enumerable.Range(1, 100_000);
var results = new ConcurrentBag<double>();
Parallel.ForEach(inputs, new ParallelOptions
{
MaxDegreeOfParallelism = Environment.ProcessorCount
}, value =>
{
double score = Math.Sqrt(value) * Math.Log(value + 1);
results.Add(score);
});
Console.WriteLine($"Computed {results.Count} scores");اخترنا ConcurrentBag لأن أكثر من Thread تضيف نتائج. لو استخدمنا List<T> مباشرة مع Add من عدة Threads، هنكون بنعدل collection غير آمن بالتزامن. لكن الـ bag لا يحافظ على ترتيب العناصر؛ لو الترتيب مطلوب، اربط كل نتيجة بالـ input index أو استخدم طريقة تجمع النتائج بصورة منظمة.
int[] numbers = Enumerable.Range(1, 1_000_000).ToArray();
int[] evenSquares = numbers
.AsParallel()
.AsOrdered()
.Where(x => x % 2 == 0)
.Select(x => x * x)
.ToArray();
Console.WriteLine(evenSquares[0]); // 4PLINQ decisions
AsParallel()يحول query إلى Parallel LINQ، ويقسم المصدر إلى partitions لمعالجة متوازية.AsOrdered()يطلب الحفاظ على ترتيب المصدر، وقد يفرض تكلفة على parallel merge.WhereوSelectيجب أن يكونا مناسبين للتنفيذ المتوازي: لا تعتمد على side effects مشتركة أو ترتيب تنفيذ معين.ToArrayمادة تنفيذية (materialization): تنتظر اكتمال query وتجمع النتائج في array.
متى لا تستخدم Parallel؟
- عمليات I/O كثيرة: استخدم APIs async، وحدد concurrency عبر
SemaphoreSlimأو Channel بدل إنشاء parallel work بلا حدود. - عمليات صغيرة جدًا: overhead قد يتجاوز تكلفة الحساب.
- عند وجود shared mutable state معقدة: إعادة التصميم إلى عمليات مستقلة غالبًا أفضل من إضافة locks حول كل خطوة.
- عند الحاجة لترتيب محدد أو نتائج deterministic: تأكد من أن كل stage تحافظ على هذا العقد.
قارن sequential و parallel باستخدام بيانات ممثلة، وراقب elapsed time و CPU و allocations والضغط على الذاكرة. لا تعتبر Environment.ProcessorCount ضمانًا أن استخدام كل cores هو أفضل اختيار للتطبيق كله؛ خذ بقية حمل العملية في الاعتبار.
Reflection والـ Attributes
الـ Reflection يسمح للكود بفحص metadata الخاصة بالأنواع والأعضاء أثناء التشغيل: اسم class، properties، methods، interfaces، والـ attributes. والـ Attribute هي metadata declarative بتضيفها للكود عشان framework أو tool يقرأها لاحقًا. ASP.NET Core و System.Text.Json و test frameworks تستخدم أفكارًا مشابهة، لكن معظم الاستخدام اليومي يتم عبر abstractions جاهزة بدل كتابة reflection يدويًا.
using System.Reflection;
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public sealed class ExportAttribute(string name) : Attribute
{
public string Name { get; } = name;
}
[Export("monthly-sales")]
public sealed class MonthlySalesExporter
{
public string Export() => "sales-data";
}
Type type = typeof(MonthlySalesExporter);
ExportAttribute? metadata = type.GetCustomAttribute<ExportAttribute>();
Console.WriteLine(type.FullName);
Console.WriteLine(metadata?.Name); // monthly-sales
foreach (MethodInfo method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
Console.WriteLine(method.Name);
}ماذا يقرأ Reflection؟
AttributeUsageيحدد الأماكن التي يسمح بوضع الـ attribute عليها، وهل تتكرر، وهل تورّث.- الـ
ExportAttributeيحمل قيمة اسمية. وجود attribute لا ينفذ behavior وحده؛ لازم كود أو framework يقرأها ويتصرف بناء عليها. typeofيعطيTypeobject يمثل metadata الخاصة بالـ class.GetCustomAttribute<ExportAttribute>يبحث عن attribute من النوع المطلوب ويرجع null إذا لم يوجد.GetMethodsيفحص methods المطابقة للـ BindingFlags. استخدم flags صريحة لتجنب افتراض أن كل methods الظاهرة هي التي تقصدها.
Trade-offs: تكلفة Reflection
Reflection مفيد في plugin discovery و serialization frameworks و dependency registration والأدوات العامة. لكنه أبطأ من direct call عادةً، ويجعل الأخطاء تظهر وقت التشغيل بدل compile time، وقد يصعّب trimming و Native AOT إذا اعتمد التطبيق على metadata أو members لا يستطيع linker اكتشافها statically. في hot paths، افحص metadata مرة واحدة وخزن delegates أو mapping plan بدل تكرار البحث مع كل request.
لو شكل البيانات معروف وقت compile، وتريد كودًا ثابتًا سريعًا مع دعم trimming/AOT أفضل، فقد يكون source generator أنسب. لو الأنواع لا تُعرف إلا وقت التشغيل (plugins مثلًا)، Reflection ما زال خيارًا منطقيًا.
File I/O والـ Serialization
ملفات النظام مورد I/O؛ القراءة والكتابة ممكن تكون بطيئة مقارنة بسرعة CPU. استخدم Stream APIs، وحافظ على ownership واضح للـ streams، وفضّل async APIs في server applications حتى لا تحجز Thread أثناء انتظار القرص أو الشبكة. والـ Serialization تحول object graph إلى representation قابلة للنقل أو التخزين؛ لكنها ليست validation ولا security boundary.
using System.Text.Json;
public sealed class JsonFileStore
{
private static readonly JsonSerializerOptions Options = new(JsonSerializerDefaults.Web)
{
WriteIndented = true
};
public async Task SaveAsync<T>(string path, T value, CancellationToken cancellationToken)
{
await using FileStream stream = new(
path, FileMode.Create, FileAccess.Write, FileShare.None,
bufferSize: 64 * 1024, useAsync: true);
await JsonSerializer.SerializeAsync(stream, value, Options, cancellationToken);
}
public async Task<T?> LoadAsync<T>(string path, CancellationToken cancellationToken)
{
await using FileStream stream = new(
path, FileMode.Open, FileAccess.Read, FileShare.Read,
bufferSize: 64 * 1024, useAsync: true);
return await JsonSerializer.DeserializeAsync<T>(stream, Options, cancellationToken);
}
}
public sealed record UserProfile(int Id, string DisplayName, DateTimeOffset UpdatedAt);شرح الأجزاء المهمة
JsonSerializerDefaults.Webيضبط defaults مناسبة لسيناريوهات الويب، ومنها naming policy الشائع للـ JSON. الـ options static/reused لتجنب إعادة بنائها في كل عملية.FileMode.Createينشئ الملف أو يستبدل محتواه. ده قرار destructive؛ لو المطلوب الحفاظ على الملف القديم عند فشل الكتابة، اكتب إلى temporary file ثم نفّذ atomic replace حسب نظام الملفات.FileAccessوFileShareيحددان صلاحية الوصول والتشارك مع عمليات أخرى.useAsync: trueيطلب فتح stream بوضع async المناسب. وعملياتSerializeAsync/DeserializeAsyncتستقبل cancellation token.await usingيضمن إغلاق stream حتى لو حصل exception، مع انتظار async disposal.- استخدام
Tيجعل التخزين عامًا، لكن يجب أن يكون النوع متوافقًا مع قواعد JSON serializer.
Serialization ليس Validation
لا تثق في JSON قادم من المستخدم لمجرد أن deserialization نجح. افحص schema والحدود والقيم المسموح بها، وتجنب قبول أنواع polymorphic عشوائية عبر type metadata غير موثوقة. حدد حجم input، وتعامل مع malformed JSON، ولا تخزن secrets داخل ملفات أو logs دون حماية. كذلك انتبه إلى versioning: تغيير property names أو required fields قد يكسر ملفات قديمة أو clients سابقة.
اختيار API
| API | مناسبة لـ | ملاحظة |
|---|---|---|
File.ReadAllTextAsync | ملف نصي صغير/متوسط تقرأه كاملًا. | تجمع المحتوى كله في string بالذاكرة. |
FileStream | ملفات أكبر أو نقل على أجزاء أو تحكم في sharing/buffering. | يحتاج إدارة صحيحة للـ lifetime. |
JsonSerializer.SerializeAsync | كتابة JSON إلى Stream بدون بناء string وسيطة. | حدد serializer options ومتطلبات التوافق. |
Unit Testing Basics: اختبر السلوك وليس تفاصيل التنفيذ
الـ Unit Test يختبر behavior صغيرة بسرعة وبشكل متكرر. الهدف مش إثبات أن كل method اتنادت بعدد مرات معين؛ الهدف التحقق من contract observable: input معين يؤدي إلى output أو side effect متوقع. الاختبار الجيد مستقل، قابل للتكرار، سريع، ويشرح intent من اسمه.
AAA Pattern
- Arrange: جهز input والـ dependencies والـ expected result.
- Act: نفّذ السلوك مرة واحدة قدر الإمكان.
- Assert: تحقق من النتيجة أو الاستثناء أو التفاعل المطلوب.
public sealed class PriceCalculator
{
public decimal ApplyDiscount(decimal price, decimal percentage)
{
if (price < 0) throw new ArgumentOutOfRangeException(nameof(price));
if (percentage is < 0 or > 100)
throw new ArgumentOutOfRangeException(nameof(percentage));
return price * (1 - percentage / 100m);
}
}using Xunit;
public sealed class PriceCalculatorTests
{
private readonly PriceCalculator _calculator = new();
[Theory]
[InlineData(200, 10, 180)]
[InlineData(100, 0, 100)]
[InlineData(80, 100, 0)]
public void ApplyDiscount_ReturnsExpectedPrice(
decimal price, decimal percentage, decimal expected)
{
// Act
decimal actual = _calculator.ApplyDiscount(price, percentage);
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ApplyDiscount_RejectsNegativePrice()
{
Assert.Throws<ArgumentOutOfRangeException>(
() => _calculator.ApplyDiscount(-1, 10));
}
}شرح الـ tests
[Theory]تسمح بتشغيل نفس test على بيانات متعددة؛ كلInlineDataحالة مستقلة.- الاختبار لا يعرف أي implementation داخلي للتخفيض؛ هو يختبر contract: السعر بعد الخصم.
Assert.Equalيقارن القيمة المتوقعة بالفعلية. نستخدم decimal لأن المثال مالي ولا نريد binary floating-point approximation.Assert.Throwsيتأكد أن input غير صالح ينتج exception من النوع المتوقع.- الاختبارات لا تحتاج database ولا HTTP؛ لذلك تظل Unit Tests فعلية وسريعة.
اختبار asynchronous code
[Fact]
public async Task LoadAsync_ReturnsUserFromRepository()
{
// Arrange
var expected = new User(7, "Mona");
var repository = new FakeUserRepository(expected);
var service = new UserService(repository);
// Act
User? actual = await service.LoadAsync(7, CancellationToken.None);
// Assert
Assert.Equal(expected, actual);
}
public sealed record User(int Id, string Name);
public sealed class FakeUserRepository(User expected)
{
public Task<User?> FindAsync(int id, CancellationToken cancellationToken)
=> Task.FromResult<User?>(id == expected.Id ? expected : null);
}
public sealed class UserService(FakeUserRepository repository)
{
public Task<User?> LoadAsync(int id, CancellationToken cancellationToken)
=> repository.FindAsync(id, cancellationToken);
}الـ test method بترجع Task والـ framework ينتظرها. لا تستخدم async void، ولا تستخدم .Result داخل الاختبار. استخدم fake/stub بسيط عندما تريد عزل وحدة عن I/O خارجي، لكن لا تجعل كل dependency fake بلا سبب: اختبر behavior الواقعية في Integration Tests منفصلة.
مبادئ جودة الاختبارات
| مبدأ | المقصود |
|---|---|
| Deterministic | نفس النتيجة في كل تشغيل؛ لا تعتمد على ساعة حقيقية أو شبكة أو random غير مضبوط. |
| Isolated | اختبار لا يعتمد على ترتيب تنفيذ اختبار آخر أو state مشتركة. |
| Readable | اسم يصف scenario والنتيجة، و Arrange/Act/Assert واضح. |
| Focused | كل test يثبت سلوكًا محددًا، لا يختبر implementation details الهشة. |
Source Generators: توليد كود وقت الـ Compile
الـ Source Generator مكوّن يعمل أثناء compilation، يقرأ معلومات من الكود الحالي أو Additional Files، ويضيف source code جديدًا إلى نفس عملية الـ compilation. بدل Reflection وقت التشغيل أو كتابة boilerplate يدويًا، يمكن توليد mapping أو serializers أو strongly typed helpers وقت البناء.
Traditional runtime reflection
الكود يفحص النوع وقت التشغيل ويكتشف properties أو attributes. مرن، لكن فيه cost runtime وقد يصعّب trimming/AOT.
Source Generator
يفحص compilation metadata أثناء build، وينتج كودًا عاديًا يدخل ضمن compilation. التنفيذ النهائي direct calls بعد التوليد.
تصور الاستخدام
[AttributeUsage(AttributeTargets.Class)]
public sealed class GenerateToStringAttribute : Attribute { }
[GenerateToString]
public partial class Customer
{
public int Id { get; set; }
public string Name { get; set; } = "";
}
// The generator adds a partial declaration during compilation:
// public partial class Customer
// {
// public override string ToString() => $"Customer {Id}: {Name}";
// }المثال يوضح شكل الـ contract والـ generated output، وليس generator implementation كامل. في مولّد حقيقي ستنشئ ISourceGenerator أو IIncrementalGenerator، تسجل syntax/semantic pipelines، تفحص النوع، ثم تضيف source باسم فريد عبر SourceProductionContext.AddSource. يفضّل حاليًا incremental generators لأنها تسمح لـ Roslyn بإعادة تشغيل الأجزاء المتأثرة فقط بدل إعادة الحساب بالكامل.
ما الذي يحتاجه Generator فعليًا؟
المولّد عادة يكون مشروع analyzer/generator منفصلًا عن التطبيق الذي يستهلكه، ويُضاف إليه Roslyn APIs كـ analyzer reference أو ProjectReference مع OutputItemType="Analyzer" و ReferenceOutputAssembly="false". توافق Roslyn host مهم: المكتبة التي يبنى عليها generator يجب أن تكون متوافقة مع compiler الموجود في SDK و IDE عند المستهلك. على خط .NET 10/C# 14 استخدم حزمة Roslyn 5.x مناسبة للـ host، وتحقق من متطلبات النشر الفعلية قبل تثبيت version في مشروعك.
الـ generator لا يعدّل الملف الأصلي ولا ينفذ business logic وقت التشغيل. الكود الناتج جزء من assembly النهائي. اكتب diagnostics واضحة لو المدخلات غير صالحة، واجعل الأسماء generated deterministic، ولا تفترض أن ترتيب ملفات المصدر ثابت.
Roslyn Analyzers و .editorconfig
الـ Analyzer يفحص الكود أثناء الكتابة أو البناء ويصدر diagnostics عندما يكتشف نمطًا قد يسبب bug أو يخالف convention. الـ Code Fix يقدر يقترح أو ينفذ إصلاحًا آليًا. الفرق عن test أن analyzer لا يشغل البرنامج؛ هو يحلل syntax/semantics بشكل static قبل التنفيذ.
root = true
[*.cs]
charset = utf-8
end_of_line = crlf
insert_final_newline = true
indent_style = space
indent_size = 4
# Prefer explicit accessibility for maintainability.
dotnet_style_require_accessibility_modifiers = for_non_interface_members:warning
# Prefer file-scoped namespaces when the team uses them.
csharp_style_namespace_declarations = file_scoped:warning
# Treat selected compiler/analyzer warnings as errors in CI.
dotnet_analyzer_diagnostic.severity = warningملف .editorconfig يحدد قواعد formatting و code style و severity ويجعلها مشتركة بين أعضاء الفريق والـ IDE والـ build. بعض القواعد formatter وبعضها analyzer. تنبيه: أسماء القواعد المدعومة تعتمد على SDK/analyzer versions، لذلك راجع rule ID/option في docs بدل نسخ إعدادات عشوائية.
<Project>
<PropertyGroup>
<AnalysisLevel>latest</AnalysisLevel>
<EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
</PropertyGroup>
</Project>AnalysisLevel يحدد مجموعة قواعد التحليل المرتبطة بالـ SDK. في CI ممكن تبدأ بتحذيرات، ثم ترفع القواعد عالية الثقة تدريجيًا إلى errors. تحويل كل warning إلى error فجأة قد يعطل البناء بسبب تحذيرات قديمة أو تحذيرات من dependencies؛ طبّق السياسة تدريجيًا مع baseline واضح.
Analyzer أم Test أم Formatter؟
| الأداة | السؤال الذي تجيب عنه |
|---|---|
| Compiler | هل الكود صحيح وفق قواعد اللغة والأنواع؟ |
| Analyzer | هل يوجد نمط خطير أو أسلوب غير مرغوب يمكن اكتشافه statically؟ |
| Formatter | هل التنسيق يطابق قواعد الفريق؟ |
| Unit/Integration Test | هل السلوك الفعلي يحقق contract عند التشغيل؟ |
dotnet CLI و NuGet: دورة حياة الكود خارج الـ IDE
الـ dotnet command-line interface هو واجهة موحدة لإنشاء المشاريع وبنائها وتشغيلها واختبارها ونشرها وإدارة الأدوات والحزم. مهم لأن نفس الأوامر يمكن تشغيلها محليًا وفي CI/CD وفي containers. و NuGet هو package manager المعتاد لـ .NET: يستعيد dependencies من package sources ويتيح توزيع libraries كحزم versioned.
# Create a solution and projects
mkdir PricingLibrary
cd PricingLibrary
dotnet new sln -n PricingLibrary
dotnet new classlib -n Pricing.Core
dotnet new xunit -n Pricing.Core.Tests
dotnet sln add Pricing.Core/Pricing.Core.csproj
dotnet sln add Pricing.Core.Tests/Pricing.Core.Tests.csproj
dotnet reference add Pricing.Core/Pricing.Core.csproj --project Pricing.Core.Tests/Pricing.Core.Tests.csproj
# Restore, build, test, and format
dotnet restore
dotnet build --configuration Release --no-restore
dotnet test --configuration Release --no-build
dotnet format --verify-no-changesكل أمر بيعمل إيه؟
dotnet new slnينشئ solution تجمع مشاريع مرتبطة.classlibينشئ library، وxunitينشئ مشروع اختبارات بقالب xUnit.dotnet sln addيضيف ملفات المشاريع إلى solution؛ هذا لا يعني أن مشروع الاختبار صار يعتمد على المكتبة بعد، لذلك نضيف ProjectReference.restoreيحل dependencies وينزل packages إلى NuGet cache. ملفاتobj/project.assets.jsonتتولد عادة ضمن هذه العملية.build --no-restoreيبني بعد restore لتجنب تكرار الخطوة.test --no-buildيشغل الاختبارات باستخدام نواتج البناء السابقة.format --verify-no-changesيتحقق أن التنسيق مطابق دون تعديل الملفات؛ مفيد كفحص في CI.
إعداد Library قابلة للنشر
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<PackageId>Contoso.Pricing.Core</PackageId>
<Version>1.0.0</Version>
<Authors>Contoso Engineering</Authors>
<Description>Core pricing primitives for .NET applications.</Description>
<PackageReadmeFile>README.md</PackageReadmeFile>
<PackageLicenseExpression>MIT</PackageLicenseExpression>
</PropertyGroup>
<ItemGroup>
<None Include="README.md" Pack="true" PackagePath="\" />
</ItemGroup>
</Project># Create a .nupkg under ./artifacts
dotnet pack Pricing.Core/Pricing.Core.csproj \
--configuration Release \
--output ./artifacts
# Publish to a private or public NuGet feed (use a secret in CI)
dotnet nuget push ./artifacts/Contoso.Pricing.Core.1.0.0.nupkg \
--source "$NUGET_SOURCE" \
--api-key "$NUGET_API_KEY"الـ .nupkg ملف ZIP يحتوي assembly و metadata و dependencies حسب إعدادات المشروع. لا تضع API keys داخل command history أو source control؛ استخدم secret store في CI أو environment injection. قبل النشر، اختبر package من مشروع مستهلك مستقل وتأكد من target frameworks و license و README و versioning.
Versioning و Package Hygiene
- استخدم Semantic Versioning عندما يناسب contract: PATCH إصلاح متوافق، MINOR إضافة متوافقة، MAJOR breaking change.
- لا تغيّر package version وتعيد نشر نفس version على feed عام؛ اعتبر الإصدار immutable.
- راجع dependencies المباشرة وغير المباشرة، وحدّثها بانتظام مع tests و security scanning.
- استخدم local tool manifest عند الحاجة إلى أدوات dotnet مرتبطة بالـ repository، حتى يقدر الفريق يستعيد نفس tool versions.
Debugger و dotnet-dump و dotnet-trace
الـ debugging مش مجرد وضع breakpoint. في الشغل الاحترافي لازم تنتقل من symptom إلى evidence: هل المشكلة exception؟ CPU عالي؟ memory بتزيد؟ Threads متعطلة؟ ولا dependency بطيئة؟ كل أداة بتجاوب نوع مختلف من الأسئلة.
| الأداة | ماذا تجمع؟ | استخدمها عندما |
|---|---|---|
| IDE Debugger | Variables، call stack، breakpoints، exceptions. | تحتاج فحص مسار تنفيذ معروف أو reproduce محلي. |
dotnet-trace | EventPipe trace لأحداث runtime/providers والـ CPU sampling حسب profile. | تبحث عن CPU hotspots أو runtime activity. |
dotnet-dump | Process memory dump لتحليل heap و threads و managed objects. | تبحث عن memory retention أو deadlock/hang evidence. |
dotnet-counters | Live performance counters مثل GC و ThreadPool و exceptions. | تريد نظرة سريعة على سلوك process أثناء التشغيل. |
Breakpoints بذكاء
- Conditional breakpoint: يتوقف فقط عندما expression تحقق شرطًا مثل
orderId == 451. - Hit count: يتوقف عند المرة رقم N، مفيد في loops.
- Exception settings: اطلب التوقف عند throw، وليس فقط عندما تصل exception غير المعالجة إلى top-level.
- Call stack: تتبع من استدعى method بدل التركيز على السطر الحالي وحده.
# List .NET processes
dotnet-trace ps
# Collect a short trace from a target process
dotnet-trace collect --process-id 1234 --duration 00:00:20
# Capture a dump for later analysis
dotnet-dump collect --process-id 1234
# Inspect dump interactively
dotnet-dump analyze <dump-file>
# Useful SOS commands inside the analysis prompt:
# threads
# clrstack
# dumpheap -stat
# dumpheap -type System.Stringاستبدل PID بالقيمة الفعلية. تأكد من صلاحيات المستخدم و compatibility بين أدوات التشخيص والـ runtime. قد تكون الـ dump حساسة جدًا: ممكن تحتوي tokens أو بيانات شخصية أو connection strings في الذاكرة؛ تعامل معها كبيانات سرية واحذفها وفق سياسة الاحتفاظ.
Debugging workflow عملي
- عرّف العرض بدقة: latency زادت؟ process memory بتزيد؟ request بتعلق؟
- حدد scope: كل instances أم واحدة؟ كل endpoints أم مسار محدد؟ منذ deploy معين أم بشكل دوري؟
- اجمع baseline counters و logs و trace قبل التغيير.
- كوّن فرضية قابلة للاختبار، مثل ThreadPool queue length مرتفع بسبب sync-over-async.
- اجمع evidence مناسب: trace للـ CPU، dump للـ memory/hang، logs و distributed traces للـ dependency latency.
- غيّر سببًا واحدًا، ثم قارن نفس القياسات تحت نفس نوع الحمل.
زيادة ThreadPool minimum، أو إجبار GC على collection، أو وضع ConfigureAwait(false) في كل مكان ليست حلولًا عامة. اجمع الدليل أولًا، وافهم سبب المشكلة، ثم اختبر تغييرًا محددًا.
أخطاء متكررة: Async و Concurrency وأدوات البناء
| الخطأ | الأثر | التصحيح |
|---|---|---|
Blocking على Task باستخدام .Result | حجز Thread، وقد يحدث deadlock أو ThreadPool starvation. | استخدم await end-to-end. |
تجاهل CancellationToken | شغل مستمر بعد إلغاء الطلب، يهدر sockets/CPU/DB capacity. | مرر token لكل API تدعمه وافحصه في الحلقات الطويلة. |
استخدام async void خارج event handler | لا يمكن await ولا إدارة exceptions بشكل صحيح. | أعد Task أو Task<T>. |
| مشاركة List أو Dictionary بين Threads دون حماية | race conditions أو state corruption أو exceptions. | صمم immutable/partitioned state أو استخدم synchronization المناسبة. |
| اعتبار Channel بديلًا لـ message broker | فقد الرسائل عند process shutdown وعدم وجود durability. | استخدم broker عندما تحتاج persistence أو cross-process delivery. |
| استخدام PLINQ على عمليات صغيرة أو I/O | overhead وتنافس على الموارد دون مكسب. | قِس أولًا واختر async I/O أو sequential execution. |
| Reflection متكرر داخل hot path | تكلفة runtime غير ضرورية. | Cache metadata/delegates أو استخدم source generation عند ملاءمتها. |
| اعتبار deserialization تحققًا من صحة البيانات | قبول قيم ناقصة أو غير منطقية أو خطرة. | نفّذ schema/domain validation وحدد حدود الحجم والأنواع. |
| نشر NuGet package دون تجربة استهلاكها | ملفات أو dependencies أو target frameworks ناقصة. | اختبر .nupkg من مشروع نظيف مستقل قبل النشر. |
| جمع dump في production ومشاركتها بلا ضوابط | تسريب أسرار وبيانات مستخدمين من الذاكرة. | قلل الصلاحيات، شفر التخزين، وحدد retention ومسار حذف آمن. |
الأداء والاختيارات الهندسية
اختيار أداة التنفيذ
| نوع المشكلة | الاختيار الأول الذي تدرسه | السبب |
|---|---|---|
| HTTP/DB/File I/O | Native async API + CancellationToken | لا تحجز worker thread أثناء I/O wait. |
| CPU-heavy independent work | Parallel/TPL بعد profiling | تقسيم الحمل على cores قد يقلل elapsed time. |
| Stream of results arriving over time | IAsyncEnumerable | تسليم تدريجي بدل تجميع كل النتائج. |
| In-process producer/consumer | Bounded Channel | تنسيق async و backpressure داخل process. |
| Shared single value update | Interlocked | عمليات ذرية بتكلفة أقل من lock عام. |
| Multi-step shared invariant | lock/SemaphoreSlim أو إعادة تصميم | حماية مجموعة عمليات كـ unit واحدة. |
| Repeated runtime metadata discovery | Cache or source generation | تقليل reflection runtime overhead. |
مقاييس لا تنسها
- Latency: زمن إتمام العملية، ويفضل قياس percentiles مثل P50/P95/P99 وليس المتوسط فقط.
- Throughput: عدد العمليات المكتملة في وحدة زمن.
- Allocation rate: حجم allocations في الثانية؛ قد يسبب ضغط GC حتى لو CPU الحساب قليل.
- ThreadPool health: عدد threads والـ queue length وتأخر العمل المجدول.
- Memory retention: هل objects تظل reachable بعد انتهاء الحاجة إليها؟ وهل الـ streams/caches تتخلص من مواردها؟
لا تحسّن بناءً على benchmark صغير غير ممثل. اختبر under realistic concurrency، وبنفس payload sizes ونسبة cache hits وحالة network/database القريبة من الإنتاج.
Knowledge Check: اختبر فهمك للجزء الثالث
الخلاصة اللي لازم تثبت
async/awaitنموذج كتابة غير حاجز فوق Tasks، وليس Thread creation.- الـ cancellation تعاوني، ولا يضمن rollback لآثار خارجية.
Taskهو الافتراضي؛ValueTaskتحسين متخصص يحتاج قياسًا.IAsyncEnumerablestream غير متزامن، وChannelطابور producer/consumer مع backpressure.- Concurrency تحتاج فهم shared state و race conditions؛ و parallelism مناسب لحسابات مستقلة بعد القياس.
- Reflection يفحص metadata وقت التشغيل؛ Source Generators تضيف كودًا أثناء compilation.
- Serialization ليست validation، والاختبارات الجيدة تثبت behavior observable.
- استخدم CLI و diagnostic tools كجزء من دورة التطوير والتشخيص، وليس فقط IDE.
هل async تعني أن كل سطر بعد await سيكمل على Thread مختلف؟
لماذا نبدأ كل عمليات HTTP Tasks قبل Task.WhenAll بدل await كل واحدة فورًا؟
هل CancellationToken يوقف Thread بالقوة؟
متى أختار ValueTask بدل Task؟
ما الفرق بين IAsyncEnumerable و Channel؟
لماذا _value++ غير آمنة بين Threads حتى لو int قراءة/كتابة بسيطة؟
هل Parallel.ForEach أفضل دائمًا من foreach؟
هل وجود Attribute على class ينفذ behavior تلقائيًا؟
هل deserialization من JSON تثبت أن البيانات صحيحة؟
ما الفرق بين Analyzer و Unit Test؟
ما الهدف من dotnet-trace مقابل dotnet-dump؟
ما الذي يجب حمايته عند جمع dump من production؟
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
التوثيق الرسمي — Official documentation
مصادر تعليمية ومتقدمة — Third-party & advanced reading
خريطة التغطية: 14 عنصر من الـ Roadmap ومكان شرحه في الدرس
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.