apbd Flashcards

Question

What is a .gitignore file for?

Answer 1

Lists patterns of files Git should not track: build output (bin/, obj/), IDE files (.vs/), secrets (appsettings.Development.json), system files (.DS_Store). Add a file after accidentally committing: git rm --cached filename.

Answer 2

A GitHub/GitLab feature (not Git itself) that wraps a branch with discussion, code review, and CI checks before merging into main. You push a branch, open a PR, get reviewed, then merge.

Answer 3

Simple workflow: main is always deployable. All work goes in a feature branch. Push the branch, open PR, review passes + CI passes → merge to main → deploy. Ideal for most teams.

Answer 4

Two permanent branches: main (production) and develop (integration). Feature branches branch from develop. Release branches branch from develop when ready. Hotfix branches branch from main for urgent production fixes.

Answer 5

Pickaxe search — finds all commits where the string 'CalculateDiscount' was added or removed from any file. Useful for tracking when a function was introduced or deleted.

Answer 6

--ff-only: merge only if fast-forward is possible, otherwise abort. --no-ff: always create a merge commit even if fast-forward would work.

Answer 7

.NET Framework (2002, Windows-only) → .NET Core (2016, cross-platform rewrite) → .NET 5+ (2020, unified platform). Even versions (6, 8, 10) are LTS (3 years). Odd versions (7, 9) are STS (18 months).

Answer 8

SDK = Runtime + Roslyn compiler + dotnet CLI + templates + MSBuild. Install SDK on your dev machine. Runtime alone on production servers.

Answer 9

Roslyn is the C# compiler. It reads your .cs files and produces IL (Intermediate Language) code in a .dll assembly. No machine code yet — that comes from JIT at runtime.

Answer 10

Just-In-Time: the CLR translates IL to native machine code on first call to each method, caches the result in memory. Second call uses the cached native code. The JIT is called RyuJIT in modern .NET.

Answer 11

On by default since .NET Core 3.0. Tier 0: method compiled fast, no optimisations (fast startup). Tier 1: when a method is called often enough, it is recompiled with full optimisations. Best of both worlds.

Answer 12

Ahead-Of-Time: compiles IL to native machine code at publish time, not runtime. Zero cold-start penalty, no .NET runtime needed on target machine. Trade-off: limited reflection, larger binary.

Answer 13

Creates a new folder MyApp/ containing MyApp.csproj and Program.cs ready to run as a console application.

Answer 14

Runs the app and automatically restarts it whenever you save a source file. Very useful during development.

Answer 15

Builds a self-contained binary for Linux x64 that includes the .NET runtime — no .NET installation needed on the target machine.

Answer 16

XML file that is your project's DNA. Contains: target framework (net8.0), NuGet package references, project references, build settings like enable.

Answer 17

Enables nullable reference type annotations. The compiler warns you when you might dereference a null reference. string? means nullable, string means non-nullable.

Answer 18

Value types (int, bool, struct, enum) store data on the stack — copying creates an independent copy. Reference types (class, string, array) store an address to the heap — copying copies the pointer, both variables point to the same object.

Answer 19

int is a 32-bit integer (whole numbers). decimal is 128-bit with 28-29 significant digits and no binary rounding errors. Always use decimal for money: decimal price = 19.99m; Never use float/double for financial calculations.

Answer 20

double uses binary floating-point representation which cannot represent 0.1 or 0.2 exactly — same as in all IEEE 754 systems. Result: 0.30000000000000004. Use decimal (suffix m) for exact decimal arithmetic.

Answer 21

"Prefix a string with $ to embed expressions: string greeting = $\"Hello

Answer 22

Prefix with @: string path = @\"C:\\Users\\Anna\\file.txt\"; — backslashes are literal, no need to escape. Good for file paths and regex.

Answer 23

In C#, == on strings compares content (overloaded). In Java, == compares references (addresses) — you need .equals(). In C#: \"hello\" == \"hello\" is true.

Answer 24

const: value known at compile time, baked into IL. readonly: value set once at declaration or in constructor, immutable afterwards but set at runtime. Use const for math constants; readonly for runtime-determined values that should never change.

Answer 25

Type inference — the compiler determines the type from the right-hand side. var name = \"Anna\" creates a string. The type is fixed at compile time; it is NOT dynamic.

Answer 26

Returns the left side if not null, otherwise the right side. int display = age ?? 0; means 'use age, or 0 if age is null'.

Answer 27

Safely accesses a member only if not null. Console.WriteLine(student?.Name); — if student is null, does nothing instead of throwing NullReferenceException.

Answer 28

Assigns a value only if the variable is currently null. age ??= 18; means 'if age is null, set it to 18'.

Answer 29

A property is a language-level construct with get and set accessors. public string Name { get; set; } — no GetName()/SetName() needed. The compiler generates the backing field automatically.

Answer 30

public string Email { get; init; } — can only be set during object initialisation (in object initialiser syntax or constructor), then immutable. Use with: var s = new Student { Email = \"x@y.com\" };

Answer 31

Syntax to set properties after construction: var s = new Student { Name = \"Anna\", Age = 21 }; Works with properties that have public set or init accessors.

Answer 32

In C# methods are NOT virtual by default. You must mark a base method virtual, then use override in the derived class. In Java all instance methods are virtual by default.

Answer 33

Abstract class: IS-A relationship, can have fields, constructors, implemented methods, and abstract holes. Interface: CAN-DO contract, no fields (typically), multiple implementations allowed. A class can implement many interfaces but inherit only one class.

Answer 34

An immutable data object. public record Person(string Name, int Age); auto-generates: constructor, properties, value equality (two records with same data are equal), ToString, Deconstruct. Use 'with' to create a copy with changes: var p2 = p1 with { Age = 26 };

Answer 35

A value type (stored on stack, copied on assignment). Good for small, performance-critical data (e.g. Point, Color). Use readonly struct for immutable structs.

Answer 36

Start with record for immutable data. Use class when you need mutable state and behaviour. Use struct (or readonly record struct) for small (<= 16 bytes) performance-critical value types.

Answer 37

C# has NO checked exceptions — all exceptions are unchecked. You are not forced to declare or catch them. Java has both checked and unchecked exceptions.

Answer 38

Use bare 'throw;' (not 'throw ex;'). 'throw;' preserves the original stack trace. 'throw ex;' resets the stack trace, losing where the error actually originated.

Answer 39

ex.Message is only the error description. ex.ToString() gives the full picture: message + exception type + complete stack trace. Always log ex.ToString().

Answer 40

Automatically calls Dispose() on IDisposable objects when they go out of scope. using var stream = File.OpenRead(\"data.txt\"); — stream is disposed at the end of the block. Essential for files, database connections, HttpClient.

Answer 41

catch (HttpException ex) when (ex.StatusCode == 404) { } — catches the exception only if the condition is true. Other HttpExceptions (e.g. 500) are not caught by this handler.

Answer 42

A type that holds a reference to a method — a typed function pointer. delegate int MathOperation(int a, int b); You can store a method in a variable, pass it to another method, and call it later.

Answer 43

Built-in generic delegate types. Func: takes T, returns TResult. Action: takes T, returns void. Predicate: takes T, returns bool. Predicate is equivalent to Func.

Answer 44

A concise anonymous method using =>. Func square = x => x * x; Multi-param: (a, b) => a + b. Multi-statement: x => { if (x < 0) return -x; return x; }. No param: () => Console.WriteLine(\"Hi\");

Answer 45

A lambda that captures variables from its enclosing scope. The compiler generates a hidden class with the captured variables as fields. The lambda captures the VARIABLE (its current value at call time), not the value at definition time.

Answer 46

var actions = new List(); for (int i = 0; i < 5; i++) actions.Add(() => Console.WriteLine(i)); — all print 5 because all lambdas share the same 'i' variable. FIX: int copy = i; inside the loop body so each lambda captures its own copy.

Answer 47

No. Since C# 5+, foreach creates a new variable per iteration, so each lambda in a foreach captures its own independent copy. The trap only applies to classic for loops.

Answer 48

When a lambda is assigned to Expression> instead of Func<...>, the compiler builds a data structure (tree of nodes) describing the expression rather than compiling it to IL. Entity Framework reads these trees and translates them to SQL.

Answer 49

event keyword encapsulates a delegate so external code can only += (subscribe) or -= (unsubscribe) — they cannot overwrite all handlers or fire the event from outside. Implements the Observer pattern. Always unsubscribe (-=) when subscriber's lifetime ends to avoid memory leaks.

Answer 50

Language Integrated Query — a set of extension methods on IEnumerable (and IQueryable for databases) that let you filter, transform, sort, group, and aggregate data using a consistent, declarative API.

Answer 51

Most LINQ operators (Where, Select, OrderBy…) do NOT execute when called — they return a recipe (IEnumerable). Execution happens when you iterate (foreach, ToList, First, Count…). The query always sees the current state of the source at iteration time.

Answer 52

ToList(), ToArray(), ToDictionary(), ToHashSet(), First(), FirstOrDefault(), Single(), SingleOrDefault(), Last(), Count(), Sum(), Average(), Min(), Max(), Any(), All(), Contains(), Aggregate().

Answer 53

Where, Select, SelectMany, OrderBy, OrderByDescending, ThenBy, GroupBy, Join, GroupJoin, Skip, Take, Distinct, Concat, Union, Intersect, Except, Zip, DefaultIfEmpty.

Answer 54

If you iterate an IEnumerable query multiple times, it re-executes from scratch each time. With a database, this means multiple round-trips. Fix: call .ToList() once, then reuse the list.

Answer 55

Filters elements — keeps only those for which the predicate returns true. Returns IEnumerable of the same type. SQL equivalent: WHERE clause.

Answer 56

Transforms (projects) each element from type T to a new type TResult. Changes the type of the sequence. SQL equivalent: SELECT clause.

Answer 57

After Select you have a new type (e.g. IEnumerable). If you try to filter on a property of the original type after Select, it won't compile because that property doesn't exist on the new type.

Answer 58

OrderBy sets the primary sort key and resets any previous sort. ThenBy adds a secondary sort criterion ON TOP of the primary. Using two OrderBy calls in sequence means the second REPLACES the first — always use ThenBy for secondary sorts.

Answer 59

First(): returns first matching element, throws InvalidOperationException if none found. FirstOrDefault(): returns null (or default value) if no match — SAFE. Always prefer FirstOrDefault in production code.

Answer 60

Returns the one and only matching element. Throws InvalidOperationException if there are zero matches OR more than one match. Use when you expect exactly one result.

Answer 61

Any() returns true if at least one element matches the predicate and STOPS at the first match. Count() > 0 traverses the ENTIRE collection. Any() is O(1) in the best case; Count() is always O(n).

Answer 62

True — this is called 'vacuously true'. There are no counter-examples, so the condition holds. Guard with .Any() first if this surprises you.

Answer 63

IEnumerable>. Each IGrouping is itself an IEnumerable with a .Key property. You iterate over groups and can iterate each group's elements.

Answer 64

INNER JOIN — only elements with a matching key on BOTH sides appear in output. Elements with no match on either side are excluded.

Answer 65

Equivalent to SQL LEFT OUTER JOIN. Every element from the left side appears; its matched right-side elements form a (possibly empty) group. Use with SelectMany + DefaultIfEmpty for flat LEFT JOIN output.

Answer 66

Flattens nested collections. If Select on a nested list gives IEnumerable> (list of lists), SelectMany flattens it to IEnumerable. Equivalent to SQL CROSS APPLY or Java's flatMap.

Answer 67

Distinct: remove duplicates. Union: unique elements from both collections. Intersect: elements in BOTH. Except: elements in first but NOT in second. Concat: all elements including duplicates.

Answer 68

General-purpose fold/reduce. Applies a function cumulatively. Without seed: first element is initial accumulator. With seed: explicit starting value. All Sum/Min/Max/Average are specialisations of Aggregate.

Answer 69

Paging. Skip(n) skips the first n elements. Take(m) takes the next m. For page P with page size S: .Skip((P-1)*S).Take(S).

Answer 70

Alternative SQL-like syntax: from s in students where s.Grade >= 3.0 orderby s.Name select s. The compiler translates it entirely to method syntax before compiling. Identical performance.

Answer 71

Query syntax: complex multi-collection joins, 'let' for temporary variables, when SQL-like form is clearer. Method syntax: simple chains, operators with no query syntax equivalent (Any, All, Count, Skip, Take, Distinct, ToList…).

Answer 72

A class should have one and only one reason to change. Don't put business logic, console UI, and data access all in one class. Each class should do one thing clearly.

Answer 73

Classes should be open for extension but closed for modification. Add new behaviour by extending (new subclass, new interface implementation) rather than editing existing code.

Answer 74

Subclasses must be substitutable for their base class without breaking the program. If code works with Equipment, it must work with Laptop or Projector without surprises.

Answer 75

Clients should not be forced to depend on interfaces they don't use. Prefer many small, specific interfaces over one large general interface.

Answer 76

High-level modules should not depend on low-level modules — both should depend on abstractions (interfaces). Inject dependencies (e.g. IRentalService) rather than instantiating concrete classes inside.

Answer 77

How closely related the responsibilities of a class are. High cohesion = class does one focused thing. Low cohesion = class does many unrelated things. Aim for high cohesion.

Answer 78

How much classes depend on each other. Tight coupling = changing one class breaks others. Loose coupling = classes interact through interfaces, easy to swap implementations.

Answer 79

Inheritance (IS-A): Laptop IS-A Equipment. Composition (HAS-A): RentalService HAS-A list of Equipment. Prefer composition when the relationship is about behaviour/capability rather than identity. Avoid deep inheritance hierarchies.

Answer 80

Abstract class: shared implementation + abstract holes, IS-A relationship, single inheritance. Interface: pure contract, CAN-DO capability, multiple implementation allowed. Common pattern in ASP.NET: interface for DI contract + abstract base for shared logic + concrete class.

Answer 81

In C#, instance methods are NOT virtual by default. You must explicitly mark a method virtual to allow overriding in subclasses. In Java all instance methods are virtual by default.

Answer 82

Prevents further inheritance (on a class) or further overriding (on a method). public sealed class GoldenRetriever : Dog { } — nothing can inherit from GoldenRetriever.

Answer 83

A class or method parameterised by type. class Container { T _value; } — works for any type while maintaining compile-time safety. Constraints: where T : class, IEntity, new() restricts what T can be.

Answer 84

C# uses reification — type information is preserved at runtime. Java uses type erasure — generic type info is removed at runtime. C# generics have better performance (no boxing for value types) and full runtime type info.

Answer 85

List: dynamic array, O(1) index access. Dictionary: hash map, O(1) key lookup. HashSet: unique elements, O(1) Contains. Queue: FIFO. Stack: LIFO. Default: List for everything else.

Answer 86

The base interface for all collections in C#. foreach works on anything implementing IEnumerable. It exposes GetEnumerator() which yields elements one at a time. All LINQ methods are extension methods on IEnumerable.

Answer 87

Creates a lazy iterator. Elements are generated one at a time on demand — the method pauses at yield return and resumes on the next MoveNext() call. Enables infinite sequences: while(true) yield return n++; Take only what you need.

Answer 88

Makes asynchronous code read like synchronous code. await releases the current thread back to the thread pool while waiting for I/O (HTTP, database, file). When the response arrives, execution resumes. Methods must return Task or Task.

Answer 89

Never use async void except in event handlers. You cannot await it, and unhandled exceptions are silently lost. Always use async Task or async Task.

Answer 90

They block the current thread while waiting for the async operation. In ASP.NET contexts this causes deadlocks because the framework's synchronisation context is already occupied.

Answer 91

Always suffix with Async: GetUserAsync(), not GetUser(). This signals to callers that the method is asynchronous and should be awaited.

Answer 92

Task t1 = GetUserAsync(id); Task t2 = GetOrderAsync(id); await Task.WhenAll(t1, t2); — start both WITHOUT immediately awaiting, then wait for both to complete.

Answer 93

Allows cancelling long-running operations. Pass it through and call cancellationToken.ThrowIfCancellationRequested() at logical checkpoints. The caller can cancel by calling Cancel() on a CancellationTokenSource.

Answer 94

List.Count is an O(1) property that reads a stored integer. .Count() is a LINQ extension method that traverses the ENTIRE sequence — O(n). Always use the property when available.

Answer 95

string text = text + more; creates a new string object each time (the old one waits for GC). In a loop with N iterations this creates N temporary strings. StringBuilder.Append() modifies a buffer in-place — use it for string building in loops.

Answer 96

TryParse returns bool (success/failure) and outputs the result. It never throws. int.Parse throws FormatException on invalid input. Always use TryParse in production code where input might be invalid.

Answer 97

Local variables/parameters: camelCase. Classes, methods, properties, namespaces: PascalCase. Private fields: _camelCase. Constants: PascalCase (NOT UPPER_CASE). Async methods: PascalCase + Async suffix.

Answer 98

Value types: == compares values (5 == 5 is true). Reference types (classes): == compares references (addresses) by default, unless overloaded. string overloads == to compare content. For custom classes, implement Equals() or use records (which have value equality built in).

Answer 99

Forces immediate execution of the entire query and stores results in a new List. After this point, changes to the source collection are NOT reflected. Use when: you need multiple passes, need random access, or want a snapshot.

Answer 100

Always filter BEFORE projecting. After Select, you have a new type and may lose access to original fields needed for filtering. The order matters: Where first narrows the set, then Select transforms what remains.

Answer 101

Range(start, count): generates { start, start+1, ..., start+count-1 }. Repeat(value, count): generates a sequence of 'count' copies of 'value'. Enumerable.Empty() creates an empty sequence.

Answer 102

Pairs up elements from two sequences by position: list1.Zip(list2, (a, b) => new { a, b }). Stops at the shorter sequence.

Answer 103

If a sequence is empty, yields one element with the default value (null for reference types, 0 for int). Used in GroupJoin + SelectMany for LEFT JOIN simulation.

Answer 104

Materialises a sequence into a Dictionary. students.ToDictionary(s => s.Id) creates a Dictionary keyed by Id. Throws if duplicate keys exist — use .GroupBy first if duplicates are possible.

Answer 105

Creates a HashSet from a sequence — unique elements with O(1) Contains. Useful for fast lookup: var studentIds = students.Select(s => s.Id).ToHashSet(); then use studentIds.Contains(id).

Answer 106

string result = value switch { 1 => \"one\", 2 => \"two\", _ => \"other\" }; Much more concise than classic switch. The _ is the default case. Can use 'or' for multiple patterns on one arm.

Answer 107

public record Point(int X, int Y); — compiler auto-generates constructor, properties, Equals, ToString, Deconstruct. 'with' creates a copy with changes: var p2 = p1 with { Y = 10 }; Original is unchanged.

Answer 108

The .NET package manager (like npm for JS, Maven for Java). Packages are hosted on nuget.org. Add: dotnet add package Newtonsoft.Json. Remove: dotnet remove package. References stored in .csproj as .

Answer 109

A container that groups multiple projects (e.g. API project + library project + test project). Visual Studio and Rider open the .sln and show all projects together. Create: dotnet new sln. Add project: dotnet sln MySolution.sln add MyAPI/MyAPI.csproj.

Answer 110

Downloads all NuGet packages referenced in .csproj from nuget.org and caches them locally in ~/.nuget/packages/. Not re-downloaded on subsequent builds if already cached.

Answer 111

enable auto-imports common namespaces (System, System.Collections.Generic, System.Linq, System.Threading.Tasks, etc.) so you don't need explicit 'using' statements for them at the top of every file.

Answer 112

net8.0 (with dot) = modern cross-platform .NET 8. net48 (no dot) = old Windows-only .NET Framework 4.8. The distinction in the csproj is intentional — the dot signals the modern platform.

Answer 113

Join = INNER JOIN (only matched pairs). GroupJoin = LEFT OUTER JOIN (every left element + a group of matched right elements, possibly empty). GroupJoin + SelectMany + DefaultIfEmpty = flat LEFT JOIN output.

Answer 114

Project description, justification of design decisions, where the project shows cohesion/coupling/class responsibilities, why you chose that class organisation and file structure. NOT copied SOLID definitions — your own concrete explanation.

Answer 115

At least 8 meaningful commits, at least 2 working branches merged into main, README.md with design justification, run instruction in README.

Answer 116

1. Students with more than one active enrollment. 2. Courses starting in April 2026 without final grades. 3. Lecturers and average grade across all their courses. 4. Student cities and number of active enrollments.

Answer 117

1. When does Git perform a fast-forward and when is a merge commit created? 2. What is the practical difference between merge and rebase? 3. How was the conflict resolved in your repository?

Answer 118

Readability of the history, correctness of Git operations, sensible commit naming, repository shows a real work process (not a single upload of the final result).

Answer 119

Both correctness of behaviour AND structure. If it works but all logic sits in one class, the main purpose is NOT achieved. Separation of responsibilities is graded as heavily as functionality.

Answer 120

Correct use of LINQ operators, result consistent with task description, readability and simplicity of the query, ability to combine several operators in advanced cases.

Answer 121

Student: maximum 2 active rentals simultaneously. Employee: maximum 5 active rentals simultaneously. System must block the rental if the limit is exceeded.

Answer 122

Penalty rules should be in ONE clearly defined place (not hard-coded in five different places). If the rule may change, it should be easy to modify without touching multiple classes. Example: a dedicated PenaltyCalculator class or a method on the Rental object.

Answer 123

dotnet test — runs all tests in the project. dotnet test --verbosity detailed for verbose output.

Answer 124

Links your local repository to a remote repository (on GitHub etc.) under the name 'origin'. After this, git push -u origin main sends your commits to that remote.

Answer 125

-u (--set-upstream) sets the tracking link between local and remote branch. After running it once, you can just type 'git push' on that branch without specifying remote and branch name.

Answer 126

Just a conventional name for the primary remote repository. It's not special — it's the default name given when you clone or when you add a remote with that name. You can rename it.

Answer 127

Creates the local folder, initialises Git, adds 'origin' remote, downloads ALL history, checks out the default branch, and sets up tracking between local and remote branches.

Answer 128

ssh-keygen -t ed25519 -C \"your.email@example.com\" to generate key pair. cat ~/.ssh/id_ed25519.pub to print the public key. Paste it in GitHub Settings → SSH Keys. Test: ssh -T git@github.com

apbd Flashcards

(152 cards)