Interview Q&A

Search

Real World Need

In-memory data storage is useful when:

• High performance is required
• Offline data handling is needed
• Unit testing should not depend on a real database
• Temporary storage is required during processing

Concept

Store objects in memory and allow querying like a lightweight database.

Implementation

public class InMemoryDb<T>
{
private readonly List<T> _data = new List<T>();
public void Add(T item) => _data.Add(item);
public IEnumerable<T> Get(Func<T, bool> predicate)
=> _data.Where(predicate);
}

// Usage

var db = new InMemoryDb<Employee>();
db.Add(new Employee { Id = 1, Name = "Sandeep" });
var result = db.Get(e => e.Name.Contains("San"));

Key Concepts

• Generic in-memory storage
• Predicate-based querying
• Not thread-safe unless synchronization is added

Real Use Cases

• Validation frameworks
• Logging metadata
• Role-based security
• API documentation metadata

Custom Attribute Example

[AttributeUsage(AttributeTargets.Property)]

public class RequiredAttribute : Attribute {}

Usage Example

public class Employee
{

[Required]

public string Name { get; set; }
}

Validation Logic

public static void Validate(object obj)
{
var properties = obj.GetType().GetProperties();
foreach (var prop in properties)
{
var isRequired = prop.GetCustomAttributes(typeof(RequiredAttribute), false).Any();
if (isRequired && prop.GetValue(obj) == null)

throw new Exception($"{prop.Name} is required");

}
}

bstract Class Meaning

Provides base behavior with shared implementation

Represents IS-A inheritance relationship

public abstract class PaymentBase
{
public void Log() => Console.WriteLine("Payment logged");
public abstract void Pay(decimal amount);
}

Summary

Interface = Capability

bstract Class = Shared Base Behavior

[ApiController]

[Route("api/[controller]")]

public class EmployeeController : ControllerBase
{

[HttpGet("{id}")]

public IActionResult Get(int id)
{
return Ok(new { Id = id, Name = "Sandeep" });
}
}

Key Characteristics:

• Lightweight
• JSON support by default
• Built-in dependency injection

Incorrect (not thread-safe)

public class Singleton
{
private static Singleton _instance;
}

Correct using double-check locking

public sealed class Singleton
{
private static Singleton _instance;
private static readonly object _lock = new object();
private Singleton() {}
public static Singleton Instance
{

get

{
if (_instance == null)
{

lock(_lock)

{
if (_instance == null)
_instance = new Singleton();
}
}
return _instance;
}
}
}

Best and simplest

public sealed class Singleton
{
public static readonly Singleton Instance = new Singleton();
private Singleton(){}
}

BlockingCollection<int> queue = new BlockingCollection<int>();

Task.Run(() =>

{
for(int i = 1; i <= 5; i++)
{

queue.Add(i);

}

queue.CompleteAdding();

});

Task.Run(() =>

{
foreach(var item in queue.GetConsumingEnumerable())
{

Console.WriteLine("Consumed " + item);

}

});

Provides automatic thread synchronization and prevents race conditions.

public static class LinqExtensions
{
public static IEnumerable<T> WhereNot<T>(this IEnumerable<T> source, Func<T,bool>

predicate)

{
foreach (var item in source)
if (!predicate(item))

yield return item;

}
}

Usage

var employees = list.WhereNot(e => e.IsDeleted);

public interface IPlugin
{

void Execute();

}

Load dynamically

var assembly = Assembly.LoadFrom("Plugin.dll");
var type = assembly.GetTypes().First(t => typeof(IPlugin).IsAssignableFrom(t));
var plugin = (IPlugin)Activator.CreateInstance(type);

plugin.Execute();

public class MyContainer
{
private Dictionary<Type, Type> map = new();
public void Register<TInterface, TImplementation>()
{
map[typeof(TInterface)] = typeof(TImplementation);
}
public TInterface Resolve<TInterface>()
{
var impl = map[typeof(TInterface)];
return (TInterface)Activator.CreateInstance(impl);
}
}

public interface ILoggerTarget
{

void Log(string message);

}

Central Logger

public class Logger
{
private readonly List<ILoggerTarget> targets = new();
public void AddTarget(ILoggerTarget target)
=> targets.Add(target);
public void Log(string message)
{
foreach (var t in targets)

t.Log(message);

}
}

Supports:

• Console
• File
• Database
• Cloud

Follows Open–Closed Principle.

wait GetData(); Rules: Avoid Result Avoid Wait Remain async end-to-end

What interviewers expect

• A clear definition tied to Power Questions in High-Impact Interview Questions projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production High-Impact Interview Questions application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in High-Impact Interview Questions architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: Used for high performance scenarios involving: File processing Large memory structures Reduced garbage collection overhead Example Span<int> numbers = stackalloc int[3] { 1, 2, 3 }; numbers[1] = 10; Runs on stack → extremely fast.

What interviewers expect

• A clear definition tied to Power Questions in High-Impact Interview Questions projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production High-Impact Interview Questions application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in High-Impact Interview Questions architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Removes least recently used entries when full.

public class LruCache<TKey,TValue>
{
private readonly int capacity;
private readonly Dictionary<TKey, LinkedListNode<(TKey,TValue)>> cache = new();
private readonly LinkedList<(TKey,TValue)> list = new();
public LruCache(int capacity) => this.capacity = capacity;
public TValue Get(TKey key)
{
if (!cache.ContainsKey(key)) return default;
var node = cache[key];
list.Remove(node);
list.AddFirst(node);
return node.Value.Item2;
}
public void Put(TKey key, TValue value)
{
if (cache.ContainsKey(key))
list.Remove(cache[key]);
if (cache.Count == capacity)
{
var last = list.Last;

cache.Remove(last.Value.Item1);

list.RemoveLast();
}
var newNode = new LinkedListNode<(TKey,TValue)>((key,value));
list.AddFirst(newNode);
cache[key] = newNode;
}
}

public class BankAccount
{
private object _lock = new object();
public decimal Balance { get; private set; }
public void Deposit(decimal amount)
{

lock(_lock)

{
Balance += amount;
}
}
public void Withdraw(decimal amount)
{

lock(_lock)

{
if (Balance >= amount)
Balance -= amount;
}
}
}

Ensures thread safety and prevents financial inconsistency.

public class RateLimiter
{
private readonly int limit;
private readonly TimeSpan window;
private readonly Dictionary<string, Queue<DateTime>> store = new();
public RateLimiter(int limit, TimeSpan window)
{
this.limit = limit;
this.window = window;
}
public bool IsAllowed(string user)
{
if(!store.ContainsKey(user))
store[user] = new Queue<DateTime>();
var q = store[user];

while(q.Count > 0 && q.Peek() < DateTime.Now - window)

q.Dequeue();

if(q.Count >= limit)
return false;

q.Enqueue(DateTime.Now);

return true;
}
}

Prevents abuse such as excessive requests, bots, and denial-of-service attempts.