General .Net Flashcards

Question

How does HttpClientFactory improve resilience?

Answer 1

Supports Polly policies like retries, circuit breakers, timeouts

Answer 2

It reuses underlying HttpMessageHandler instances with connection pooling.

Answer 3

public void ConfigureServices(IServiceCollection services) { services.AddHttpClient("RetryClient") .AddPolicyHandler(GetRetryPolicy()); } private IAsyncPolicy GetRetryPolicy() { return HttpPolicyExtensions .HandleTransientHttpError() // Handles 5xx, 408 and network errors .OrResult(msg => msg.StatusCode == System.Net.HttpStatusCode.TooManyRequests) // 429 .WaitAndRetryAsync( retryCount: 3, sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), // 2s, 4s, 8s onRetry: (outcome, timespan, retryAttempt, context) => { Console.WriteLine($"Retry {retryAttempt} after {timespan.TotalSeconds}s due to {outcome.Result?.StatusCode}"); }); }

Answer 4

At first glance, this looks okay because HttpClient is IDisposable. But disposal does not close TCP connections immediately. Instead, the underlying sockets linger in a TIME_WAIT state for ~2 minutes. ➡️ If your app makes frequent requests and recreates HttpClient each time, you can hit socket exhaustion (running out of available ports).

Answer 5

Using a struct instead of a class can cause performance issues if the struct is large and copied frequently, since structs are value types and each assignment or method call copies the entire object. This increases memory usage and CPU overhead. Another issue is boxing and unboxing, which happens when a struct is converted to an object or interface type, leading to additional allocations on the heap. In these cases, a class is more efficient because only the reference is copied.

Answer 6

In C#, a struct is a value type, while a class is a reference type. Structs are usually stored on the stack (or inline), and their values are copied when assigned or passed. Classes are stored on the heap, and variables hold a reference to the object. Unlike classes, structs cannot inherit from another struct or class, though they can implement interfaces. Structs also cannot define a parameterless constructor. Typically, I use structs for small, lightweight, immutable data (like Point or DateTime) and classes for larger, more complex objects that need inheritance, polymorphism, or reference semantics.

Answer 7

IEnumerable is the most basic collection interface. It provides deferred iteration over a sequence of elements but does not allow modification. ICollection inherits from IEnumerable and adds methods for adding, removing, and counting items (Add, Remove, Count, Clear). It represents a modifiable collection. IList inherits from ICollection and adds index-based access (this[int index]) and insert/remove at a specific position, making it suitable for collections where order matters and you need random access. IReadOnlyList represents a read-only, indexable collection. You can access items by index and iterate, but cannot modify the collection. ✅ When to use each: IEnumerable → when you just need to iterate over a sequence. ICollection → when you need modification operations like add/remove. IList → when you need index-based access and order-sensitive operations. IReadOnlyList → when you want to expose a collection safely without allowing modifications.

Answer 8

In C#, Task represents an asynchronous operation and is part of the Task Parallel Library (TPL). It can return a result (Task) or be non-returning (Task). void is used for asynchronous event handlers, but it should generally be avoided in async methods because it cannot be awaited and exceptions cannot be caught easily. ValueTask is a more memory-efficient alternative to Task for methods that may complete synchronously and frequently return a result immediately. Unlike Task, ValueTask avoids allocating a new object on the heap in these cases. However, ValueTask comes with some restrictions, like it should not be awaited multiple times and is more complex to manage correctly. ✅ Usage guidance: Use Task for most async methods. Use ValueTask for performance-sensitive, frequently-completing synchronous operations. Use void only for event handlers.

Answer 9

“ref passes a variable by reference and allows reading and writing, out passes by reference for returning values and must be assigned in the method, and in passes by reference as read-only, useful for large structs to avoid copying.” ref: Passes a variable by reference. The variable must be initialized before being passed, and the method can read and modify it. out: Also passes a variable by reference, but it is intended to return values from a method. The variable does not need to be initialized before being passed, but the method must assign a value before returning. in: Passes a variable by reference for read-only purposes. The method cannot modify the variable, making it useful for performance when passing large structs without copying. ✅ When to use: ref → when you need to read and write a value in the method. out → when you want to return multiple values from a method. in → when you want to avoid copying large structs but don’t want the method to modify them.

General .Net Flashcards

(34 cards)