Interview

Question 1

Class vs Struct vs Record

Answer 1

Class is a reference type, struct is a value type, record is a reference type. The record is immutable used primarily for DTOs and one way operations. Classes can be inherited. Structs cannot be inherited.

Question 2

Value type vs reference type

Answer 2

A value type is most commonly stored on the stack. A reference type is stored on the heap type of memory. Depends on the context the variable is declared. Local value types are stored on the stack. Objects of reference variables are stored on the heap. If the value is declared inside a class it will be on the heap.
TLDR: Value types and reference types go to a different type of memory.

Question 3

Abstract class vs interface

Answer 3

Abstract classes can contain implemented methods and interfaces can’t. C# 8 interfaces can have default implementation. Abstract classes cannot be instantiated but can have all members of classes (props, methods, ctrs, fields)
Abstract classes are used to define a base class while interfaces are used to define an implementation. Classes can implement multiple interfaces while can inherit from only one class.

Question 4

OOP principles

Answer 4

Encapsulation, abstraction, inheritance, polymorphism
Encapsulation - data implementation is done through public methods and enclosed in classes
Abstraction - classes don’t need to know the actual implementation of other classes they need to be based on their abstractions, abstract classes or interfaces
Inheritance - inheritance provides the ability for classes to reuse code from upper base classes. It also provides the ability to polymorphism
Polymorphism- This is the so called overloading and overriding of methods. Overloading is achieved same name, different number of parameters, overriding is achieved through overriding virtual methods.

Question 5

Managed vs unmanaged code

Answer 5

Code that executes under the control of the runtime is managed code and is eligible for garbage collection. Unmanaged code is code that is not under control and has to be disposed of. COM components, ActiveX interfaces and Windows API functions are such examples. Unmanaged code is executed by the OS directly

Question 6

Const vs readonly

Answer 6

Const is assigned value in compile time. Readonly is assigned value in runtime.

Question 7

IDisposable pattern

Answer 7

Basic Dispose pattern - implementing IDisposable and in the Dispose method dispose of any resources. Because finalizing methods in unpredictable you need to check whether the Dispose method is called from Dispose(bool) or it is called from the finalizer in order to avoid disposing of something already disposed of

Question 8

Garbage Collection

Answer 8

Background process that collects unused references and frees up memory. There are three conditions that trigger garbage collection:
Low physical memory, low memory on the heap or gc.collect

Question 9

Garbage collection generations

Answer 9

Gen 0 - youngest objects, short lived objects
Gen 1 - short lived objects buffer to long lived objects. If the gc does not free enough memory from gen 0 objects it collects from gen 1 and then goes to gen 2.
Gen 2 - long lived objects here, static data for example that lives during the whole process.
LOH (Gen 3) - objects larger than 85 MB objects in this gen are collected with gen 2 objects

Question 10

.NET Framework vs .NET Core / 5,6,8

Answer 10

.NET Framework is a development framework offers API development MVC etc. / .NET Core is a platform that includes ASP.NET, UWP / .NET Core is an open source platform / .NET Framework is not open source
.NET Core is cross platform it can run on all platform and supports all kind of development / NET Framework is used solely for windows development. / .NET Core is shipped as a collection of Nuget Packages / .NET Framework is installed as a single app installer
Offers scalability and performance with comparison to Framework /
Core is compatible with all operating systems /
.NET Core comes up with a very lightweight CLI, it can be used in IDE
.NET Framework is heavy on the CLI
.NET Framework has the Code Access Security

Question 11

.NET Standard

Answer 11

.NET Standard is a set of APIs compatible with all .NET versions . If you need a portable library that’s compatible with Framework, Core and Xamarin then use the .NET Standard.

Question 12

async and await

Answer 12

IO bound operations and CPU bound operations
Waiting for some data -> io bound operation
Expensive computation -> cpu bound operation

Question 13

Task.WhenAll and Task.WhenAny

Answer 13

Multiple tasks return when the unwrapped results of all tasks
when any returns the

Question 14

Blocking the current thread with Task

Answer 14

Task.Wait or Task.Result, Task.WaitAll, Task.WaitAny, Thread.Sleep

Question 15

Task vs Thread

Answer 15

A task can have multiple processes, a thread is just a process
A Task returns a result / Tasks can be chained / Tasks propagate exceptions / Tasks are using Thread Pool threads
A Thread is a lowlevel single process

Question 16

Concurrency vs Parallelism

Answer 16

Concurrency is running on a single CPU while Parallelism is running on multiple processors

Question 17

Array vs List

Answer 17

Array is fixed size, List doubles its size and allocates its memory /
Arrays generally have better performance, Arrays need to have default values

Question 18

LinkedLists

Answer 18

LinkedList is a data structure every element is chained to the previous one and the next one. LinkedLists contain members that have pointers to each other but can allocate different parts of the memory unlike arrays.

Question 19

EF core load related entities

Answer 19

Eager loading -> include / initial query
Explicit Loading -> the related data is loaded at a later time /
context.Entry(blog).Collection( –load some prop–)

Lazy Loading -> the related data is transparently loaded when the navigation property is accessed / LazyLoading requires using a package Microsoft.EFCore.Proxies /lazy loading loads the entities only when accessed

Question 20

Gang of Four Design Patterns

Answer 20

Creational, Structural, Behavioral patterns

Question 21

Structural Patterns

Answer 21

Composite Pattern
- abstract root class
- implementation of “leaf” class that inherit from the root class

Question 22

Abstract Factory

Answer 22

Abstract Factory
-One class that is the abstract factory
-There are different factories that are implementation of the base abstract factory
-These implementations have public methods offering different interpretation

Question 23

FactoryMethod

Answer 23

Factory Method
-Abstract Product and Implementations of abstract product
-Abstract Creator and an implementation of the creator
-The implementation of the creator utilizes the implemented creators

Question 24

Singleton Pattern

Answer 24

single instance across the application

Question 25

Mediator Pattern

Answer 25

Abstract mediator and a concrete mediator
Abstract colleagues and concrete colleagues
Colleagues are registered in the the mediator. A typical example is a chat client. The mediator is a typical behavior pattern

Question 26

RESTFUL Services

Answer 26

The service is based on the Client-Server model.
The service uses HTTP Protocol for fetching data/resources, query execution, or any other functions.
The medium of communication between the client and server is called “Messaging”.
Resources are accessible to the service by means of URIs.
It follows the statelessness concept where the client request and response are not dependent on others and thereby provides total assurance of getting the required data.
These services also use the concept of caching to minimize the server calls for the same type of repeated requests.
These services can also use SOAP services as implementation protocol to REST architectural pattern.

Question 27

REST API best practices

Answer 27

-Define API operations in terms of HTTP methods
GET, POST, PUT, DELETE
-Conform to HTTP semantics - media types / non-binary types the types is json or xml / for binary types
-Filter and paginate data
-Support partial responses for large binary data
-Use HATEOAS / hypertext as the engine of application state
-Versioning a RESTful web API

Question 28

CLEAN architecture

Answer 28

In circles - Entities/Use Cases;Business layer /Controllers/Web Devices;DB;External

Question 29

REST API OPTIONS
REST API HEAD

Answer 29

-returns info about the api endpoints and content-type
-returns info about a resource

Question 30

SOLID

Answer 30

Single Responsibility
Open - Closed principle
Liskov substitution
Interface segregation
Dependency inversion

Question 31

Liskov substitution

Answer 31

Subclasses should be substitute for their base classes
subclasses commonly change the implementation of certain method applying more restrictive measures. This can be solved by introducing a shared interface between the classes.

Question 32

AWS EC2 instances

Answer 32

virtual machines ec2 autoscaling

Question 33

AWS Load Balancer

Answer 33

directing traffic

Question 34

AWS lambda functions

Answer 34

without any access to the underlying architecture, resources are allocated solely by aws

Question 35

git merge vs git rebase

Answer 35

rebase creates commit for every commit in the base branch

Question 36

AWS SQS and AWS SNS

Answer 36

Simple queue system, simple notification system

Question 37

Amazon ECS (Elastic container service)

Answer 37

highly scalable docker containers

Question 38

Amazon EKS (Elastic kubernetes service)

Answer 38

Docker containers but orchestrated by kubernetes

Question 39

AWS Fargate

Answer 39

containers but solely manage by AWS without access to the containers themselves

Question 40

Clustered vs non-clusted indices

Answer 40

clustered index can be only one used to sort data
non-clustered index is a structure separate from the data rows and has pointers to the actual data

Question 41

ACID SQL term

Answer 41

Atomicity Consistency Isolation and Durability
Atomicity is either everything is committed or none,
Consistency - data is consistent
Isolation every transaction runs in isolation without knowledge of other transactions
Durability - changes are saved even after system failure

Question 42

SQL Sharding

Answer 42

Sharding is a technique that splits data into separate rows and columns held on separate database server instances in order to distribute the traffic load. Each small table is called a shard. Some NoSQL products like Apache HBase or MongoDB have shards, and sharding architecture is built into NewSQL systems.

Question 43

IQueryable vs IEnumerable

Answer 43

IQueryable is used for querying the data in out memory.
IEnumerable pulls the data and then queries it in memory
IQueryable is executing a select query server side with all filters.

Question 44

Circuit Breaker Pattern

Answer 44

In usual faults in the system it is better to use the retry pattern
In other possible scenarios the circuit breaker is the exact opposite of retry.

Circuit breaker acts as a proxy for operations that might fail. The proxy should monitor the number of recent failures that have occurred and decide whether to allow the operation to proceed or simply return an exception.

The pattern has several states Closed, Open, Half -Open.
Closed is success, Open is for failures, half open gives a chance for the system to fix itself.

Question 45

Domain Driven Design

Answer 45

Ubiquitous Language - use of common language that is shared between experts and domain members
Bounded Contexts - divides large systems into distinct contexts each with its own specific model and terminology
Entities and Value Objects - Entities represent objects with unique identities, while value objects are objects that are defined by their attributes.
Aggregates - clusters of associated objects.
Domain Events - Represent meaningful state changes within the domain.

Question 46

Sagas pattern

Answer 46

Problem: Each service has its own database. Some business transactions span multiple services how to update the database

Solution: If a transaction spans multiple services. It is a saga. Sequence of local transactions. Each local transaction updates the db and publishes a message or event to trigger the next local transaction in the saga. If a local transaction fails then the saga executes a series of compensating transactions that undo the changes.

This is like compensating for ACID transactions but for microservices.

Question 47

Dictionary and HashMap how they work under the hood

Answer 47

dictionary is a collection of key value pairs
hashtable is a collection of key value pairs based on their hash value

hashtable is non-generic collection. you can have different types of key-value pairs
dictionary requires types and can store only one type
data retrieval is slower because of boxing unboxing

Question 48

Distributed Transactions

Answer 48

A transaction or a system of transactions that span over several microservices.

Question 49

HashSet

Answer 49

Stores only unique elements

Question 50

IoC vs Dependency Inversion

Answer 50

Inversion of Control (IoC): Inversion of Control is a design principle that refers to the reversal of control flow in a software system. It involves delegating the control of the flow of execution to an external component or framework, often through the use of design patterns such as the Dependency Injection pattern. In IoC, the control flow of a program is shifted from the application to a container or framework, which manages the creation and lifecycle of objects and controls their interactions. This promotes loose coupling and allows for greater flexibility and testability within the application.

Dependency Inversion: Dependency Inversion is a specific principle within the broader concept of Inversion of Control. It refers to the practice of designing software modules and components in a way that high-level modules do not depend on low-level modules directly, but both depend on abstractions. This principle encourages the use of interfaces or abstractions to define the interactions between modules, rather than concrete implementations. By depending on abstractions, the higher-level modules become independent of the lower-level implementation details, enabling easier maintenance, extensibility, and testing.