Interview Q&A

Remove duplicates without using LINQ Distinct()

What interviewers test

• Hashing fundamentals
• Time vs memory trade-offs
• Whether you understand why Distinct() works

Real-world scenario

You are processing millions of user IDs coming from logs or Kafka messages.

You must remove duplicates fast and predictably.

Optimized approach (HashSet)

public static List<int> RemoveDuplicates(int[] input)
{
var seen = new HashSet<int>();
var result = new List<int>();
foreach (var item in input)
{
if (seen.Add(item)) // Add returns false if already exists
{

result.Add(item);

}
}
return result;
}

Complexity

Aspect Value

Time O(n)

Space O(n) (hash storage)

Why this is better than naive loops

• Nested loops = O(n²) ❌
• HashSet = constant-time lookup ✅

Interview Tip:

Say “I prefer HashSet because it gives O(1) average lookup and preserves intent clearly.”

Explain async / await with a real production

scenario

What interviewers test

• Thread utilization
• Scalability thinking
• Non-blocking I/O knowledge

Real-world scenario

API calls:

• Database
• Payment gateway
• Email service

Blocking threads = server collapse under load

Bad (Blocking)

public string GetUser()
{
var response = httpClient.GetAsync(url).Result; // Blocks thread

return response.Content.ReadAsStringAsync().Result;
}

Good (Async, scalable)

public async Task<string> GetUserAsync()
{
var response = await httpClient.GetAsync(url);
return await response.Content.ReadAsStringAsync();
}

Why async/await matters

• Thread is released during I/O wait
• ASP.NET can serve more concurrent requests
• No thread starvation

Key interview line

“Async doesn’t make code faster; it makes servers scalable.”

IEnumerable vs ICollection vs IList

What interviewers test

• Execution pipeline understanding
• Abstraction knowledge

Hierarchy

IEnumerable

└── ICollection

└── IList

IEnumerable<T>

• Read-only iteration
• Lazy execution

IEnumerable<int> numbers = GetNumbers();
foreach (var n in numbers) { }

✅ Best for streaming, read-only, deferred execution

ICollection<T>

• Adds count + add/remove

ICollection<int> list = new List<int>();
list.Add(1);

✅ When modifying collection without index access

IList<T>

• Index-based access

IList<int> list = new List<int>();
int first = list[0];

✅ When order & index matter

Interview rule of thumb

“Expose the least powerful interface required.”

Logic

• Count character frequency.
• Traverse string again to find the first with count = 1.

string input = "swiss";
Dictionary<char, int> map = new Dictionary<char, int>();
foreach (char c in input)
map[c] = map.ContainsKey(c) ? map[c] + 1 : 1;
foreach (char c in input)
{
if (map[c] == 1)
{

Console.WriteLine(c);

break;

}
}

Handle millions of records efficiently

What interviewers test

• Memory pressure awareness
• Streaming & batching

❌ Bad (Loads everything)

var users = db.Users.ToList(); // Memory explosion

✅ Streaming (Best)

await foreach (var user in db.Users.AsAsyncEnumerable())
{

Process(user);

}

✅ Batching

const int batchSize = 1000;
for (int i = 0; i < total; i += batchSize)
{
var batch = GetBatch(i, batchSize);

ProcessBatch(batch);

}

Key principles

• Never load everything
• Prefer streams
• Control memory explicitly

Dependency Injection without any framework

What interviewers test

• SOLID
• Architecture fundamentals

Step 1: Abstraction

public interface IMessageService
{

void Send(string message);

}

Step 2: Implementation

public class EmailService : IMessageService
{
public void Send(string message)
{

Console.WriteLine("Email: " + message);

}
}

Step 3: Injection

public class Notification
{
private readonly IMessageService _service;
public Notification(IMessageService service)
{
_service = service;
}
public void Notify(string msg)
{

_service.Send(msg);

}
}

Why this matters

• Loose coupling
• Testable code
• Swappable implementations

struct vs class (real-world)

What interviewers test

• Memory & performance awareness

Use struct when:

• Small
• Immutable
• Value-type behavior

public readonly struct Point
{
public int X { get; }
public int Y { get; }
}

Use class when:

• Large
• Mutable
• Shared references

public class User
{
public string Name { get; set; }
}
Interview statement

“Structs live on stack or inline, classes live on heap with GC cost.”

Design a rate limiter

What interviewers test

• Concurrency
• Thread safety
• System design

Token bucket (simple)

public class RateLimiter
{
private readonly int _limit;
private int _count;
private DateTime _windowStart = DateTime.UtcNow;
private readonly object _lock = new();
public RateLimiter(int limit)
{
_limit = limit;
}
public bool Allow()
{

lock (_lock)

{
if ((DateTime.UtcNow - _windowStart).TotalSeconds >= 1)
{
_count = 0;
_windowStart = DateTime.UtcNow;
}
if (_count < _limit)
{

_count++;

return true;
}
return false;
}
}
}

Used in

• APIs
• Login attempts
• OTP systems

LINQ vs IQueryable

What interviewers test

• Deferred execution
• DB performance

LINQ (IEnumerable)

var data = users.Where(x => x.Age > 30).ToList();

• Executes in memory

IQueryable

var data = db.Users.Where(x => x.Age > 30);

• Translates to SQL
• Executes in DB

Interview line

“IQueryable builds expressions; IEnumerable executes them.”

🔟 Write clean, production-ready C# code

What interviewers test

• Professional maturity

Principles

• Small methods
• Clear naming
• No magic values
• Proper exceptions

public class OrderService
{
public void PlaceOrder(Order order)
{
if (order == null)

throw new ArgumentNullException(nameof(order));

Validate(order);

Save(order);

}
private void Validate(Order order)
{
if (order.Total <= 0)

throw new InvalidOperationException("Invalid total");

}
private void Save(Order order)
{

// persistence logic

}
}