C# and .NET Interview Questions and Answers: 60 Questions from Easy to Hard

var nums = new List<int> { 1, 2, 3 };
var big = nums.Where(n => n > 1);    // nothing runs yet

nums.Add(4);
Console.WriteLine(big.Count());      // 3: the query sees the 4

var snapshot = nums.Where(n => n > 1).ToList();   // runs now
nums.Add(5);
Console.WriteLine(snapshot.Count);   // 3: copied before the Add
Console.WriteLine(big.Count());      // 4: runs again, sees the 5

// Translated to SQL: WHERE, ORDER BY and TOP/LIMIT run in the database
var page = await db.Employees
    .Where(e => e.DeptId == 4)
    .OrderBy(e => e.Name)
    .Take(20)
    .ToListAsync();

// Typed as IEnumerable: loads every employee, then filters in memory
IEnumerable<Employee> all = db.Employees;
var slow = all.Where(e => e.DeptId == 4).ToList();

// Blocks a thread; can deadlock in WPF or WinForms
var user = GetUserAsync(id).Result;

// Frees the thread while waiting
var user2 = await GetUserAsync(id);

// Library code: no need to resume on the caller's context
string json = await http.GetStringAsync(url).ConfigureAwait(false);

// Sequential: about 300 + 200 + 400 = 900 ms
var profile = await GetProfileAsync(empId);
var leaves = await GetLeavesAsync(empId);
var attendance = await GetAttendanceAsync(empId);

// Concurrent: about 400 ms, the time of the slowest call
var pTask = GetProfileAsync(empId);
var lTask = GetLeavesAsync(empId);
var aTask = GetAttendanceAsync(empId);
await Task.WhenAll(pTask, lTask, aTask);
var profile2 = await pTask;   // already complete, no extra wait

try
{
    await gateway.RefundAsync(orderId);
}
catch (HttpRequestException ex)
    when (ex.StatusCode == HttpStatusCode.ServiceUnavailable)
{
    await retryQueue.AddAsync(orderId);      // only for HTTP 503
}
catch (Exception ex)
{
    logger.LogError(ex, "Refund {OrderId} failed", orderId);
    throw;    // not "throw ex;", which loses the stack trace
}

public class GlobalHandler(ILogger<GlobalHandler> log)
    : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext ctx,
        Exception ex, CancellationToken ct)
    {
        log.LogError(ex, "Unhandled error on {Path}", ctx.Request.Path);
        ctx.Response.StatusCode = StatusCodes.Status500InternalServerError;
        await ctx.Response.WriteAsJsonAsync(
            new ProblemDetails { Title = "Something went wrong" }, ct);
        return true;   // handled: stop here
    }
}

// Program.cs
builder.Services.AddExceptionHandler<GlobalHandler>();
builder.Services.AddProblemDetails();
app.UseExceptionHandler();

app.UseExceptionHandler("/error");   // first: wraps everything below
app.UseStaticFiles();

app.Use(async (context, next) =>
{
    var sw = Stopwatch.StartNew();
    await next(context);             // the rest of the pipeline runs here
    app.Logger.LogInformation("{Path} took {Ms} ms",
        context.Request.Path, sw.ElapsedMilliseconds);
});

app.UseAuthentication();             // who are you?
app.UseAuthorization();              // are you allowed?
app.MapControllers();

builder.Services.AddTransient<IOtpGenerator, OtpGenerator>();
builder.Services.AddScoped<ILeaveService, LeaveService>();
builder.Services.AddSingleton<IHolidayCache, HolidayCache>();
builder.Services.AddDbContext<HrDb>(o =>
    o.UseSqlServer(builder.Configuration.GetConnectionString("Hr")));

// Bug: a singleton that captures a scoped DbContext
public class HolidayCache(HrDb db) : IHolidayCache { /* ... */ }

// Eager loading: one query with a JOIN
var orders = await db.Orders
    .Include(o => o.Customer)
    .Where(o => o.OrderDate >= from)
    .ToListAsync();

// Projection: only the columns the API returns
var rows = await db.Orders
    .Where(o => o.OrderDate >= from)
    .Select(o => new { o.Id, o.Total, CustomerName = o.Customer.Name })
    .ToListAsync();

public class LeaveService
{
    public event EventHandler<LeaveApprovedArgs>? Approved;

    public void Approve(int leaveId)
    {
        // ... save the approval
        Approved?.Invoke(this, new LeaveApprovedArgs(leaveId));
    }
}

public record LeaveApprovedArgs(int LeaveId);

// Subscriber
service.Approved += (sender, e) => SendSms(e.LeaveId);
// service.Approved = null;   // compile error outside LeaveService

var actions = new List<Action>();
for (int i = 0; i < 3; i++)
    actions.Add(() => Console.Write(i));
foreach (var a in actions) a();        // 333

actions.Clear();
foreach (var n in new[] { 0, 1, 2 })
    actions.Add(() => Console.Write(n));
foreach (var a in actions) a();        // 012

public class LeaveCalculatorTests
{
    [Theory]
    [InlineData(1, 18)]   // joined in January: the full year
    [InlineData(7, 9)]    // joined in July: half the year
    public void Leave_is_prorated_by_joining_month(int month, int expected)
    {
        // Arrange
        var calc = new LeaveCalculator(annualDays: 18);
        // Act
        int days = calc.ForJoiningMonth(month);
        // Assert
        Assert.Equal(expected, days);
    }
}

builder.Services.AddHttpClient<SmsClient>(c =>
{
    c.BaseAddress = new Uri("https://sms.example.in/");
    c.Timeout = TimeSpan.FromSeconds(10);
});

public class SmsClient(HttpClient http)
{
    public Task<HttpResponseMessage> SendAsync(string phone, string text)
        => http.PostAsJsonAsync("v1/send", new { phone, text });
}