Lil hinn minn / għal I/O, .NET jipprovdi l- għal — tħabbita komputazzjonijiet fuq multiplot cores. Id-distinzjoni ewlenija: / huwa għal I/O concurrency (non-blocking waits), filwaqt li , , u PLINQ huma għat-tqassim tal-CPU-intensive work.
Lil hinn minn / għal I/O, .NET jipprovdi l- għal — tħabbita komputazzjonijiet fuq multiplot cores. Id-distinzjoni ewlenija: / huwa għal I/O concurrency (non-blocking waits), filwaqt li , , u PLINQ huma għat-tqassim tal-CPU-intensive work.
asyncawaitasyncawaitTask.RunParallelasync/await → I/O-bound concurrency. Frees the thread during waits (DB, network).
Does NOT add CPU parallelism.
Parallelism → CPU-bound work spread across MULTIPLE CORES (computation, processing).
Use Task.Run, Parallel.For/ForEach, PLINQ.
// run a CPU-intensive computation on a thread pool thread (don't block the caller)
int result = await Task.Run(() => ExpensiveComputation());
// run multiple in parallel and combine
var tasks = items.Select(item => Task.Run(() => Process(item)));
var results = await Task.WhenAll(tasks); // wait for all
Task.Run jixxeddul work fuq thread pool thread — uża dan biex tqassam CPU-bound computation (LI JKOLIX għal I/O, fejn async/await diġà jiffi mingħajr threads addizzjonali).
// Parallel.For/ForEach — process a collection across cores
Parallel.ForEach(items, item => Process(item)); // automatically uses multiple cores
Parallel.For(0, 1000, i => Compute(i));
// PLINQ — parallel LINQ
var results = data.AsParallel().Where(x => IsValid(x)).Select(Transform).ToList();
Parallel.For/ForEach u PLINQ (.AsParallel()) awtomatikament jiddistribbwixxu l-work fuq cores — ħanut għal CPU-heavy processing ta' elementi indipendenti. (Xejn immolla biss għal genuinely CPU-bound, work ta' daqs konsiderevoli — hemm overhead.)
// parallel code accessing SHARED state needs synchronization or thread-safe types
lock (_lock) { _counter++; } // lock for mutual exclusion
Interlocked.Increment(ref _counter); // lock-free atomic
var dict = new ConcurrentDictionary<string, int>(); // thread-safe collection
L-għarfien ta' Tasks u parallelism lil hinn minn async/await huwa għerf importanti tal-livell senior għat-tibni ta' C# applications b'prestazzjoni tajba, u l-distinzjoni kruċjali bejn I/O concurrency u CPU parallelism huwa l-għarfien ewleniju — punt ta' confusion komuni. async/await jħandle I/O-bound concurrency (iliberar threads matul waits) iżda ma jżidx CPU parallelism, filwaqt li CPU-bound work (computations, data processing) jibbenefika minn parallelism attwali fuq cores permezz ta' Task.Run (offload CPU work għal thread pool threads), Parallel.For/ForEach, u PLINQ (.AsParallel()).
L-għarfien liema għodda tajjeb — async/await għal I/O, it-TPL parallelism tools għal CPU-bound work — huwa essenzjali għal ottimizzazzjonj ta' prestazzjoni effettivi, minħabba li l-użu tal-għodda ħamsa (eż. stennija li async taffrettax computation, jew spinnjug threads għal I/O li async jħandle effiċjentement) huwa ineffettiv.
". Ekwalment importanti huwa l-għarfien ta' thread safety: kodiċċ parallel ta' aċċess għal shared state jeħtieġ synchronization (lock, Interlocked għal atomic operations, jew thread-safe collections bħal ConcurrentDictionary) biex nevita race conditions — kwistjoni ta' korrettezza kritiċi fil-parallel code.
L-għarfien tal-I/O-vs-CPU distinzjoni, it-tools ta' parallelism (Task.Run, Parallel, PLINQ), u t-thread-safety requirements huwa validi għat-tisqrieba ta' correct, performant concurrent u parallel C#.
Minkejja li applikazzjonijiet moderni spiss jeħtieġu I/O concurrency u CPU parallelism, u minħabba li l-għażla ta' approach rig u t-trap ta' thread safety korrettament huma dak li jagħmlu parallel code effettiv u korrett, dan huwa għerf senior importanti u ta' frekwenza għal C# development sensittiv għal prestazzjoni.