Language Flashcards
Single Responsibility Principle (Definition, Violation Example, Better Approach)
A class should have only one responsibility which means a class should have only one reason to change form having submit method. What if submit functionality changes. It should only deal with fields to display. Don’t mix data representation and business logic
Open Closed Principle (Definition, Violation Example, Better Approach)
A class should be open for extension but closed for modification. Eg: Order Processer is built to handle single order but new requirement needs bulk order processing. Can’t extend, can’t modify. Use Order Processor interface and use polymorphism
Liskov Substitution Principle (Definition, Violation Example, Better Approach)
A derived object must be able to take the place of base object which means derived object must confirm to all the behavior (methods) in base object. Eg: If we build a quick order form for an existing lengthy order form by inheriting directly since the fields are available, but it does not exactly behave like regular order form. In a submit validation function if we are referencing fields that are null, then it breaks the application.
Interface Segregation Principle (Definition, Violation Example, Better Approach)
Many smaller interfaces are better than one large general interface so that class are not forced to implement behavior is doesn’t have. Eg : If order form is built a contract(interface) with validate, submit but we have new requirement to except emergency order which only needs submit then emergency order form will be forced to implement validation when is doesn’t need it. IValidatable, ISubmittable
Dependency Inversion Principle (Definition, Violation Example, Better Approach)
A higher level module should not depend on lower level module directly. Instead both should depend on abstractions which inverts the direction on dependency. Abstractions should not depend on details(concrete). Concrete should depend on abstractions. Eg: If submit service depends directly on particular DB object, we will violate OCP if we change. Instead depend on database abstraction.
Polymorphism
Ability of an object to take different forms based on context. Flexibility, Generic Programming
Inheritance
Building specialized classes using existing classes. Reusability, Extensibility
Encapsulation
Bundling state and behavior into one unit and defining interactions and access levels to it. Integrity, Security
Abstraction
Model complex problem statement into abstractions that will focus on what it does not how it does. Readability, Modularity
Variance, Covariance, Contravariance, Invariance, Bivariance
Variance : how generics behave when assigned to variables of different generic type in inheritance. Allows safe type conversion in generics for flexibility but also ensuring type safety. Only for interfaces and delegates because they only define behavior. Classes are not variant (invariant) as they store state and that breaks type safety. Bivariance not supported in c#
Generics are invariant by default, not polymorphic. List<Animal> can't be assigned to List<Dog></Dog></Animal>
Covariance (out, write only) : Type conversion allowed for return types. Only produces values. Eg: IEnumerable
Contravariance (in, read only): Type conversions allowed of input types. Only consumes values. Eg: IComparer
Generics
Allow type parameterization for reusing type safe code that works on different types without boxing/unboxing and casting. Value types can stay in stack without heap allocation
Advantages :
1. Reuse code, no duplication
2. Type safe code, no runtime errors
3. Performance better, no boxing/unboxing. Eg: Collections are faster
Abstractions vs Concrete
Loosely coupled design. We can switch implementation behind abstraction easily without affecting in front. Easy to maintain (new requirements don’t need as many changes), easy to test (unit test with mocks instead of real dependencies). Helps in dependency injection
in vs out vs ref
Initialization, Value vs ref type, use cases
in : Read only order. Passes read only reference. Needs initialization, optimization because avoids copies (large structs as ref instead of value), ensures immutability. In reference type, fields can be changed but their reference can’t be assigned (object assignment).
out : Blank order. No initialization, explicit assignment must in function else compiler error, multiple return values
ref : Editable order. Needs initialization, modify existing data. Preserve object identity for object and avoid memory overhead for large structs
Private constructor class vs static class vs sealed class
Private Constructor Class: prevents instantiation from outside the class. Singleton Pattern, Static Factory Method – Forces object creation via a factory method. API token creation class through controlled factory method
Static class cannot be instantiated and only contains static members.
Utility/Helper Methods, Global Constants, Extension Methods. Single source of truth for business logic calculations
Sealed class prevents inheritance. Security & Integrity – Prevents modification via inheritance that breaks business logic. Performance optimization for JIT.
Why IList Invariant
Why class invariant
Why Array covariant
Lists have indexes which means they store some state internally. They allow both reading and writing, thus invariant
Generic class can have both input (parameters) and output (return values), which would lead to type safety issues.
MyClass<Dog> dogs = new MyClass<Dog>();
MyClass<Animal> animals = dogs; // ❌ Type safety broken
animals.SetItem(new Cat()); // ❌ Dog container now has a Cat!
Dog dog = animals.GetItem(); // ❌ Unsafe cast</Animal></Dog></Dog>
Subtypes can be assigned to array of base but it is not type safe. It was taken from other languages but C# is known for type safety and hence generics.
Why is IComparer<T> contravariant (in), but IComparable<T> is invariant?</T></T>
IComparer<T> is contravariant (in) because it only consumes values as method parameters. It never returns T, so there's no risk in allowing a IComparer<Animal> to compare Dog objects.</Animal></T>
IComparable<T> is invariant because the CompareTo method both takes and returns T, preventing safe variance</T>
Why is Func<T> covariant (out), and Action<T> contravariant (in)?</T></T>
Func<T> is covariant (out) because it only produces (returns) values. Safe because Func<T> only returns values—never accepts input. Func allows contravariance in input types and covariance in return type</T></T>
Action<T> is contravariant (in) because it only consumes values as input. Safe because Action<T> only takes input—it never returns T.</T></T>
If List<T> Has Capacity, Why Even Use Arrays?</T>
Even if capacity defined, more memory is allocation than required. Memory overhead for metadata as well. List only supports jagged array, Array is better for grid
Use cases : Game Development (Performance critical)
Arrays (T[]) are true fixed-size contiguous memory, making them faster for predictable workloads. List<T> also uses contiguous memory but resizes dynamically, which adds occasional overhead.</T>
How List<T> Resizes Internally in C#</T>
if List<T> runs out of space, it allocates a new array (usually double the previous size). Copies all elements from old to new.
Garbage Collector (GC) will eventually clean up the old array.</T>
Copying process is O(n) ,so avoid frequent resizing
Best practices for optimization:
Use List<T>(int capacity) if size is known in advance.
Use EnsureCapacity(int min) to optimize bulk inserts.
Use TrimExcess() to release unused memory.</T>
If intention with sealed class is to prevent unintended modification, just stop using virtual. Why not?
Because methods can be hidden with new keyword preventing corrupt logic
Stack vs Heap
Stack: Fast, Simple, Short-lived, Predictable
Stores local variables and value types (primitive, struct). LIFO helps allocate and free automatically when a function call ends. Fast no complex memory management.
Heap: Flexible, Dynamic, Slower, Persistent
Stores objects, reference types (class, string, array).
Allows dynamic memory allocation, objects can exist beyond a function’s scope, supports polymorphism.
GC to clean up making it slower than the stack.
Performance balancing by avoiding memory fragmentation
Why pass by value, Why pass by reference
Pass by value for safety : to avoid side effects, so send copies
Pass by reference for efficiency : to avoid copying large data instead use the same to modify in function
Value types, Reference types, Boxing/Unboxing
Value Types : Stack, Fast (stack allocation), passed by value, safe mutation(copies sent) No GC, simple data types
Reference Types : Reference on stack, value on Heap, Shared by reference, Slow (GC overhead), passed by reference implicitly, alive as long as reference exists
Boxing : Value types had to be converted to reference types for collections that operate on objects (ArrayList, Hashtable)
Create object(CPU cost) - Heap allocation, store metadata (memory, GC overload) - Slower
Unboxing: Extracting value type from reference type. No new heap allocation. Explicit casting, runtime exceptions
Mutability vs Immutability
Mutability is for performance optimization. Memory reused efficiently. Altered unexpectedly risking security, causes side effects
Immutability is for security when multithread to avoid race conditions. Any modification creates new instance and each thread gets it.
String vs StringBuilder
String is immutable reference type. Modification creates new instance, for security. To enable safe sharing & caching while preventing unwanted modifications (high GC pressure).
Use: When working with small strings. When concatenation is simple & known at compile time. When immutability is required (e.g., security-sensitive data like passwords)
a = "hello"; string b = a; // Both point to the same memory b += " world"; // Creates a new string, a is unchanged If string were mutable, changing b would accidentally change a too
StringBuilder : Mutable reference type. Modification happens in place, better performance. Use : When modifying a string frequently (loops, large data processing). When concatenating many strings dynamically.
Anonymous types vs Tuples
Temporary, inline, compiler generated type, readonly properties, LINQ
Anonymous Type : inline lightweight objects to group/encapsulate temporary values instead of creating class/struct for one time use. Type is compiler generated. Properties are readonly (good for safe LINQ operations)
Use : Optimized for LINQ: Allows grouping and transformation on-the-fly. Safe data transformations
Limitations: Can’t be returned from methods because no explicit type, type information lost outside local scope, immutable(can’t be modified)
Tuples :Lightweight temporary objects to return multiple values from methods without creating classes/structs
out vs tuples
out requires pre-defined variables. Must initialize/assign
use in TryParse
Tuples don’t require modifying input parameters. Cleaner way of writing code
Tuple vs ValueTuple
Before C# 7, tuples were reference types (heap), immutable, slow(boxed)caused performance issues. Doesn’t have named properties.
ValueTuple is a value type, so it’s stored on the stack, no GC workload and is faster, not boxed, immutable, has named properties, can be deconstructed
Tuple
Created via Tuple.Create() or new Tuple<T>()</T>
ValueTuple
Uses (T1, T2) syntax or ValueTuple<T1, T2>
Why Is out and ref Hard to Use in LINQ?
LINQ uses expressions (like lambda functions), which don’t allow modifying parameters.
But out and ref require modifying parameters.
What are records
Record is a special reference type for immutable, data-centric objects. It simplifies object equality, cloning, and pattern matching while reducing boilerplate code (class definition).
Before record, developers had to write a lot of boilerplate code for simple data-transfer objects (DTOs) or immutable objects. Unlike classes, records compare by value, making them ideal for data models, DTOs, and immutable objects. With record struct in C# 10, developers can also use stack-allocated records for better performance.
✅ Automatic property initialization (immutable).
✅ Built-in value-based equality.
✅ No need for manual cloning (With expression).
var vs dynamic
var enables type inference at compile time—the compiler determines the type based on the assigned value. Type is determined at compile time. Strongly typed—once inferred, the type cannot change. Improves readability when the type is obvious. To support anonymous types and LINQ
dynamic defers type checking until runtime, making it useful for interacting with loosely typed objects (e.g., COM objects, reflection, JSON). Type is determined at runtime. Allows switching between types dynamically. Useful for COM objects, JSON, reflection, and scripting APIs. No compile-time checks; errors are caught at runtime.
What’s LINQ? Why?
LINQ (Language Integrated Query) was introduced in as a way to unify data access across different sources(collections, databases, xml) using a consistent, readable syntax, type safe.
Before : Hard to read code, different syntax for each data source, error prone, tight coupling to raw sql, sql injection prone
Performance Optimization: Defers execution, evaluates one at a time for in-memory reducing memory usage, uses query optimization to minimize DB load and reuses execution plan
How does LINQ work internally
LINQ works through deferred execution, iterators, and expression trees. LINQ to Objects executes queries using IEnumerable<T> with iterators (yield return), while LINQ to SQL translates queries into SQL using IQueryable<T> and expression trees. LINQ providers optimize execution by delaying evaluation until results are needed, ensuring efficiency for both in-memory and database queries.</T></T>
LINQ to Objects
Compile phase : Syntax converted to lambda expression and translated into delegate (Func<int, bool>).
Deferred execution :
Using Iterators (yield return) It creates IEnumerable<T> iterator and query not executed immediately. Execution starts when iterated</T>
Process: In-memory
Execution happens only when results are accessed (lazy execution). Only the necessary elements are processed, improving performance.
Streaming Execution: Where filters values one-by-one instead of loading all results at once.
Select applies transformation on-the-fly.
LINQ to SQL
Query Compilation: Creates Expression Tree (Expression<Func<Employee, bool»).
Deferred Execution :
Expression Tree is Passed to the Query Provider (IQueryable<T>). The provider (DbContext in EF) holds this expression tree.</T>
Execution:
When iterated, expression tree translated into SQL and executed on DB not in-memory. DB optimizes query
Materialization (Conversion to Objects) : DB returns the results, and EF maps rows to C# objects (IEnumerable<Employee>).</Employee>
LINQ Performance Optimization
Streaming Execution (Lazy Evaluation in LINQ to Objects). Filters and transformations execute one element at a time, reducing memory usage. Does not create intermediate collection
SQL Optimization (LINQ to SQL / EF Core). Uses indexes and query optimization to minimize database workload.
Only necessary columns are selected (e.g., SELECT Name FROM Employees).
Compiled Queries (Caching in EF Core). Compiles queries once and reuses execution plans, improving performance.
LINQ Methods : Lazy, Eager
Deferred Execution (Lazy Methods) – Query execution is delayed until results are iterated.
Filter, Sort, Group, Project, Join, Set
Immediate Execution (Eager Methods) – Query is executed and results are stored immediately.
Quantifiers, Conversion(ToList), Element Retrieval, Aggregation
LINQ Filtering : Where
Deferred, Streaming Execution, Lazy Evaluation : Uses an iterator (yield return). Filtered one at a time - low memory usage. Only necessary elements are processed.
Returns IEnumerable<T>.</T>
LINQ Projection (Select, SelectMany)
Uses foreach internally.
Select : Convert each element and return collection of collections
SelectMany : Flattens nested elements and returns flatten collection
FirstOrDefault() on Empty List
Output: default value of T
default(int), which is 0.
If it’s a reference type (List<string>), it would return null.</string>
OrderBy().FirstOrDefault() on Empty List
Output: 0
✅ Why? Even though OrderBy() is used, the list is still empty, so FirstOrDefault() returns 0.
✅ Trick: Sorting an empty collection does not throw an error.
Take(0) on a List
Output: 0
✅ Why? Take(0) creates an empty sequence—it doesn’t return the first element.
❌ Common Mistake: Expecting 1.
DefaultIfEmpty() vs. FirstOrDefault()
Output: 1
✅ Why? DefaultIfEmpty() returns one element, which is the default value (0 for int).
❌ Common Mistake: Expecting 0 (thinking it’s empty).
All() vs. Any() on Empty List
Any Output: true
✅ Why? All() on an empty collection always returns true because there’s nothing to contradict the condition.
❌ Common Mistake: Expecting false.
All Output: false
Rule of Thumb:
.All(condition) on an empty list → ✅ Always true
.Any(condition) on an empty list → ❌ Always false
Skip().Take() on a Small List
var numbers = new List<int> { 1, 2, 3 };
var result = numbers.Skip(10).Take(5);
Console.WriteLine(result.Count());</int>
Output: 0
✅ Why? .Skip(10) skips more elements than available, leaving an empty sequence.
Reverse() vs. OrderByDescending()
What is the difference?
var numbers = new List<int> { 3, 1, 2 };
var result1 = numbers.OrderByDescending(n => n);
var result2 = numbers.Reverse();</int>
OrderByDescending(n => n) sorts in descending order → {3, 2, 1}
Reverse() modifies in-place and doesn’t return a new sequence!
Correct way to reverse a collection correctly in LINQ:
var result = numbers.AsEnumerable().Reverse();
GroupBy() and List Reference
var numbers = new List<int> { 1, 2, 3, 1, 2 };
var groups = numbers.GroupBy(n => n);
numbers.Add(4);
Console.WriteLine(groups.Count());</int>
Output: 3, NOT 4
✅ Why? GroupBy() executes lazily, so modifying numbers after calling GroupBy() can lead to unexpected behavior.
✅ Fix: Use .ToList() to force execution:
Distinct() on Reference Types
var people = new List<Person>
{
new Person { Name = "Alice" },
new Person { Name = "Alice" }
};</Person>
var distinctPeople = people.Distinct();
Console.WriteLine(distinctPeople.Count());
Output: 2
✅ Why? Distinct() compares object references by default, not property values.
Fix: If you want it to compare by Name, use:
var distinctPeople = people.DistinctBy(p => p.Name);
Where().FirstOrDefault() vs FirstOrDefault()
Question: What is the difference?
var numbers = new List<int> { 1, 2, 3 };
var result1 = numbers.Where(n => n > 1).FirstOrDefault();
var result2 = numbers.FirstOrDefault(n => n > 1);</int>
result1 filters first, then calls FirstOrDefault().
✅ result2 finds first matching element immediately (more efficient).
❌ Common Mistake: Thinking they are identical.
🔹 Performance Tip: Use .FirstOrDefault(predicate) instead of .Where().FirstOrDefault() to avoid unnecessary iteration.
Count() vs Any()
Question: What is the better way to check if a list has elements?
if (numbers.Count() > 0) { /* Do something / }
if (numbers.Any()) { / Do something */ }
Use .Any() instead of .Count() > 0
Why?
.Count() iterates the entire collection for non-lists.
.Any() stops after finding the first element (faster).
Select() on a Large List
Question: Will this cause performance issues?
var numbers = Enumerable.Range(1, int.MaxValue);
var result = numbers.Select(n => n * 2);
No issues unless iterated.
✅ Lazy execution prevents immediate memory usage.
❌ Common Mistake: Assuming it consumes huge memory immediately.
Fix: Use .Take(n) if you need only part of the result:
var result = numbers.Select(n => n * 2).Take(100);
Distinct() on Large Collections
Question: How does this perform?
var numbers = Enumerable.Range(1, 10000000).Select(n => n % 100).Distinct();
Creates a set to track unique values (faster than sorting).
❌ Common Mistake: Thinking Distinct() sorts the collection.
🔹 Alternative: Use .ToHashSet() for faster lookups.
OrderBy() vs Sort()
Question: Which is better?
var list = new List<int> { 3, 1, 2 };
var sorted1 = list.OrderBy(n => n);
list.Sort();</int>
OrderBy() creates a new sorted sequence (does not modify the original list).
✅ Sort() modifies the original list in place (faster for lists).
🔹 Performance Tip: Use .Sort() for lists; use .OrderBy() for IEnumerable<T>.</T>
ForEach() vs foreach
Question: Which is better?
list.ForEach(n => Console.WriteLine(n));
foreach (var n in list) Console.WriteLine(n);
.ForEach() is a List<T> method (not available on IEnumerable<T>).
✅ foreach works on any collection.
🔹 Performance Tip: Use foreach for better readability and debugging.</T></T>
Aggregate() vs Sum()
Question: Which is better for summing values?
var sum1 = numbers.Aggregate(0, (acc, n) => acc + n);
var sum2 = numbers.Sum();
Sum() is optimized for summing.
❌ Common Mistake: Using Aggregate() when Sum() is more readable and optimized.
