Questions d'entretien : .NET Developer

Deferred execution means a LINQ query usually runs only when its results are enumerated.

• Operators such as Where and Select build a pipeline without reading the source immediately.
• Each enumeration can run the pipeline again and observe changes made to the source.
• Materializers such as ToList, ToArray, and ToDictionary execute the query and store a snapshot.

IEnumerable<T> executes delegates over objects, while IQueryable<T> represents an expression tree for a query provider.

• Enumerable operators invoke compiled delegates in .NET as elements are enumerated.
• An IQueryable<T> provider can translate supported expressions into SQL or another remote query language.
• Crossing to AsEnumerable stops provider translation, so later filtering happens in memory.

An IQueryable provider can translate only expression-tree nodes and methods it explicitly supports.

• The lambda is captured as data describing operations rather than compiled directly as a delegate.
• Arbitrary application methods have no automatic equivalent in SQL or another provider language.
• Unsupported expressions should be rewritten, mapped to provider functions, or evaluated only after an explicit in-memory boundary.

Streaming operators can yield results incrementally, while buffering operators must consume some or all input first.

• Where and Select can usually produce each item as soon as they receive it.
• OrderBy must read and sort the full input before yielding its first result.
• Buffering affects memory use and the time until the first result becomes available.

Multiple enumeration can repeat the underlying work and may produce different results.

• A database-backed or file-backed sequence can perform I/O again for every pass.
• A stateful or changing source may return a different set on the next enumeration.
• Materialize once when a stable snapshot or repeated traversal is actually required.

SelectMany projects each source element to a sequence and flattens those sequences into one result.

• Select preserves nesting, so selecting child collections produces a sequence of collections.
• SelectMany emits the children as one sequence and can retain the parent through its result selector.
• It corresponds conceptually to nested iteration and often to a join-like expansion in query providers.

Any() answers existence and can stop at the first element, while Count() computes a total.

• For an enumerable without a cheap count, Count() may traverse the entire sequence.
• Query providers commonly translate Any() to an existence check and Count() to an aggregate.
• Use Count() only when the number itself is needed, not as a substitute for existence.

GroupBy semantics are consistent in intent, but provider translation and result shape can differ from LINQ to Objects.

• In memory, GroupBy creates group objects that can be enumerated with all their elements.
• A database provider most reliably translates grouping when each group is reduced with aggregates such as Count or Sum.
• Materializing full groups may require additional shaping or client-side work, so generated queries must be understood.

The compiler rewrites an async method into a state machine that can suspend and resume around incomplete awaits.

• Locals needed after an await become fields of the generated state machine.
• If an awaited operation is already complete, execution may continue synchronously without suspension.
• The method returns a task-like object that represents completion, result, or failure.

Async and await do not inherently create a new thread.

• For asynchronous I/O, the thread returns to the pool while the operating system or runtime waits for completion.
• The continuation is scheduled when the operation completes and may run on a thread-pool thread or captured context.
• CPU-bound work needs explicit parallel execution such as Task.Run when offloading is appropriate.

ConfigureAwait(false) tells an await not to require resuming on the captured context.

• It matters with a custom SynchronizationContext or non-default TaskScheduler, as found in classic UI applications and older ASP.NET.
• ASP.NET Core normally has no request synchronization context, so it often makes no observable difference there.
• Library code may use it to avoid unnecessary context coupling, but it does not make the operation itself faster or parallel.

A cancellable operation should accept a CancellationToken and pass it through every cancellable dependency.

• Cancellation is cooperative, so code must observe the token or call APIs that observe it.
• ThrowIfCancellationRequested produces OperationCanceledException and preserves standard task cancellation semantics.
• A token signals a request rather than forcibly stopping work, and cleanup still remains the operation's responsibility.

ValueTask is useful only when avoiding a Task allocation on frequently synchronous completion provides measured value.

• Task is simpler, supports repeated awaiting, and should remain the default return type.
• A ValueTask must normally be awaited once or converted to a Task before reuse or composition.
• ValueTask has a larger value representation and extra usage rules, so it can cost more when completion is usually asynchronous.

Blocking can deadlock when the caller holds a context that the awaited continuation needs in order to resume.

• The caller blocks its context thread while Result or Wait waits for task completion.
• The continuation is queued back to that same context and cannot run because the thread is blocked.
• Async all the way avoids this cycle, while ConfigureAwait(false) can remove context capture in suitable library code.

Async void should be reserved for event handlers because callers cannot await or compose it.

• Exceptions escape to the current synchronization context instead of being stored in a returned Task.
• The caller cannot know when the operation completes or cancel it through a task-based contract.
• Returning Task makes completion, failure, testing, and composition explicit.

Task.WhenAll creates a task that completes after every supplied task has completed.

• WhenAll does not start operations or create threads; it only observes and coordinates the supplied tasks.
• Awaiting the combined task propagates failure, while the combined task retains all inner exceptions for inspection.
• If no task faults but at least one is canceled, the combined task ends in the canceled state.

An exception from an async Task-returning method is stored in the returned task and rethrown when it is awaited.

• Exceptions before and after an incomplete await both become task failure once execution is inside the async method.
• Await rethrows the failure without wrapping it in AggregateException in normal use.
• A task that is never awaited or otherwise observed can hide failure from the calling flow.

IAsyncEnumerable<T> streams elements asynchronously, while Task<IEnumerable<T>> asynchronously produces a complete enumerable.

• await foreach can wait between elements without buffering the entire result first.
• A Task<IEnumerable<T>> normally signals that collection setup or materialization finishes before enumeration starts.
• Cancellation can be supplied to asynchronous enumeration with WithCancellation or an enumerator cancellation token.

TaskCompletionSource<T> exposes a Task whose completion is controlled explicitly by other code.

• It adapts callbacks, events, or external completion signals to the task-based asynchronous model.
• SetResult, SetException, and SetCanceled determine the final state, while TrySet variants handle races safely.
• RunContinuationsAsynchronously can prevent continuations from running inline inside the code that completes the source.

A delegate is a type-safe object that references a method with a compatible signature.

• It can reference static or instance methods and can be passed as data.
• Multicast delegates maintain an invocation list and call each target in order.
• Func, Action, and Predicate are common generic delegate types for values, procedures, and conditions.