What is media-Type formatter?
Media type formatter is used for handle serialization(converting objects to json) and de-serialization
(converting json to .net objects).not only json it is used for xml and other formats also.
JsonMediaTypeFormatter -> application/json
XmlMediaTypeFormatter -> application/xml , text/xml
When client sends or receives the response , api checks "Content-Type" for request and
Accept/header for response
We can create own custom methods by inherting from "MediaTypeFormatter"
Difference between 400 and 404?
400 : when request is invalid( when data type is wrong if u missed required parameters ,invalid json)
404 : the resource that we request is doesn't exist
Aspect 400 Bad Request 404 Not Found
Cause Invalid request syntax or data Valid request, but resource is missing
Problem lies with The request data or format The URL/resource requested
Typical fix Check input data, headers, or body Check the endpoint or resource ID
Status Code 400 404
Difference b/w local storage, Cache, Session ?
Observables:
An observable is a stream of data that can be observed over time it is used to handle asynchronous
data sources like http request , timers ..it can emit multiple values over time
Plain Observable creation :
Const Observable = new Observable (observer =>{
[Link](1);
[Link](2);
[Link](3);
}
Rxjs Observable:
Rxjs provides tools that deals with complexity of data (map,filter and of)
Of -> it is also "rxjs" tool that is used to create observable
Ex: import { of } from 'rxjs';
const myObservable = of(1, 2, 3);
Creating Observable from Events : used for debounce(kind of user serch)
ex:
import { fromEvent } from 'rxjs';
const button = [Link]('myButton');
const clickObservable = fromEvent(button, 'click');
How to use rxjs in angular
data$: Observable<number>;
ngOnInit() {
[Link]$ = of(1, 2, 3, 4, 5); //$ is symbol of observable
}
and template :
@for(number of data$ | async ; track number){
<div>{{number}}</div>
}
RxJs operates allow to transform,manuplate, combine and work with observable in various ways like
( trasnsform data from an observable, retry failed http request)
[Link]$ = of(1, 2, 3, 4, 5).pipe(
map(value => value * 2)
); // tranform the data
Error handling withRxJs:
Error handling is a common challenge in async programming(catch Error, retry)
[Link]$ = [Link]('/api/data).pipe(
retry(3)
CatchError(error =>{
[Link]('Error')
})
);
When you want to wait multiple http request before updating the view
const users$ = [Link]('/api/users');
const products$ = [Link]('/api/products');
forkJoin([users$, products$]).subscribe(([users, products]) => {
[Link]('Users:', users);
[Link]('Products:', products);
});
we can unsubscribe with using two methods with using takeUntill and using ngOnDestory method
Private destory$ = new subject<void>();
[Link]('/api/data').pipe(takeUntill([Link]$)).subscribe(value => [Link](value)); //take
untill automaticcallu destoryed when component is destoryed)
Another way
ngOnDestory(){
[Link]$.next();
[Link]$.complete();
Map: filter :
numbers = of(1,2,3); numbers1 = of(1,2,3);
Sqare = [Link](map(x:number)=>x*x); numbers2 = of(1,2,3);
[Link](x=> [Link](x)); const merged = merge(numbers1, numbers2);
[Link](x => [Link](x));
to consume data emitted by obervable , need to subscribe the it. Subscribing to an Observable is similar
to registerining event listener
const numbers = of(1, 2, 3);
[Link](
value => [Link](value), // each value emitted by observable
error => [Link](error), // handles the error
() => [Link]('Completed') // when an observable completes
);
Difference between subject and observable:
Feature Observable Subject
Type Only Observable (data producer) Both Observable + Observer (producer
& consumer)
Unicast vs Unicast — each subscriber gets a separate Multicast — all subscribers share the
Multicast execution(in factory everyone get their own same data stream (like yt video)
product)
Can push ❌ No (data defined inside the observable) ✅ Yes, using .next(value) we can
data inside observable we need to callnext call after subscribing all
manually? of them
Start ✅ Yes, emits when a subscriber joins ✅ Yes, but can also emit from external
emitting on events
subscribe?
Use case One-to-one data streams (e.g., HTTP call) Shared events or manual triggers (e.g.,
button clicks, live updates)
Example of(1, 2, 3) emits values when [Link](1) pushes value to
subscribed all subscribers
Different Types of Subjects:
Subject Type Remembers Last Value? Replays Past Values? Emits on .complete() Initial Value Required
only?
Subject ❌ No ❌ No ❌ No ❌ No
BehaviorSubject ✅ Yes ✅ Yes (last one) ❌ No ✅ Yes
ReplaySubject ✅ Yes ✅ Yes (N values) ❌ No ❌ No
AsyncSubject ✅ Yes (only last) ✅ Yes (last one only) ✅ Yes ❌ No
Subject:
Shares emit values to all current subscribers
Does not remember old values
Only send data to subscribers after they subscribe
When you want to emit data to multiple users without remebering past data
const subject = new Subject<number>();
[Link](val => [Link]('A:', val)); // Subscribed early
[Link](1);
[Link](2);
[Link](val => [Link]('B:', val)); // Subscribed late
[Link](3);
A: 1
A: 2
A: 3
B: 3
Behaviour Subject
Rembers the last value and sends that value after subscribing
if there is no last value return initial value
Ex:
const behaviorSubject = new BehaviorSubject<number>(0); // initial value
[Link](val => [Link]('A:', val));
[Link](1);
[Link](2);
[Link](val => [Link]('B:', val)); // Subscribed later
[Link](3);
A: 0
A: 1
A: 2
B: 2
A: 3
B: 3
ReplaySubject
It remebers n number of last values
If I subscribing now it will the me n number of last values
Ex:
const replaySubject = new ReplaySubject<number>(2); // buffer last 2 values
[Link](1);
[Link](2);
[Link](3);
[Link](val => [Link]('A:', val));
A: 2
A: 3
Async Subject:
it will emit the value of completed state
Emits only the last value, and only when complete() is called.
ou want subscribers to get a single final result (e.g., once a calculation or request is done).
const asyncSubject = new AsyncSubject<number>();
[Link](val => [Link]('A:', val));
[Link](1);
[Link](2);
[Link](3);
[Link](val => [Link]('B:', val));
[Link](4);
[Link](); // 🚨 Only now values are emitted
A: 4
B: 4
Vertical Scaling and Horizontal Scaling
Vertical Scaling:
Upgrading a single server (increasing CPU,RAM,storage etc)
Works well for moderate growth but has a fixed hardware limit. If the server fails, the entire system may go
down (single point of failure)
used in monolithic and small applications
Horizontal Scaling:
Instead of relying on one machine , we add multiple servers to distribute the workload.
When one system reaches limit , new instance can be added [Link] better availability,fault
tolerance(if one of the system does not work rest will work) and cost effectiveness
Used in distributed systems,microservices and cloud computing environments
We need to load balncer to ensure requests are evenly distributed across servers or databse replicas
This prevents overloading of single machine and optimize the resource utilization.
Not only servers we can also scale databases by creating database replicas where multiple database instances
And replicas are created
Distribute load across multiple nodes
Prevent single points of failure
Improve read/write efficiency
Hybrid Scaling:
Hybrid scaling = Start by scaling up (vertical) individual machines for efficiency, and then scale out (horizontal) by adding
more machines for scalability and fault tolerance.
DI:
It is a design pattern used in software development to achieve IOC between classes and their dependencies
Instead of class creating its own dependencies the are injected from outside.
Why we use DI:
1. Loosely Coupling : classes depend on abstraction (interfaces), not concrete implementations.
2. Easier Testing: We can inject mock and dependencies in tests.
3. Reuseable, Maintainbility and Scalability
Role of DI:
Separate object creation from object usage.
Supports solid principles:
Single Responsibility
open/Closed Principle
Dependency inversion
Dependency Injection and Services in [Link] Core: A Comprehensive Guide | by Ravi Patel | Medium
Types of dependency injection:
1. Constructor Injection
[Link] Injection
[Link] Injection
Constructor Injection :
Define dependencies as a parameter in the constructor
DI resolves the dependency ,inject them when creating instance for class
Use Case:
Dependecy are manadatory for class to work and dependency are available or initialized before class is intialized.
When you have multiple dependecies and promotes immtability
Advantages Limitation
Clear declaration of dependencies if there are multiple dependencies that lead to constructor
overload
Make sure instance is not null not used for optional dependency
Promotes immutability
Property Injection:
. Setting dependency through public properties rather than constructors
DI container sets the property after object is created
Used when dependency is optional
Advantages Limitation
Optional dependecy can lead to null refernce bcz of null reference
Flexibility to set dependency after object creation less clear decoaration of dependency compared to constructor.
Method Injection
Passing dependency directly through method parameter
DI provides the dependecy when the mathod is called.
Dependency only needed for specific method
When you want to avoid constructor overload
When you want to limit the scope of dependency
LifeSpan of DI:
Transient : A new instance is provided everytime it is requested
public string GetGuids()
{
return $"Service1: {_guidService1.GetGuid()} and Service2:{_guidService2.GetGuid()}";
}
for above request new instance for _guidService1 and another instance _guidService2 for single apicall
Scoped: One instance per one request( example per api call)
For above request guidService1 and guidService2 have same instance
SingleTon: A singleton instance for long time application
even when we call another api call
all will return one Guid
What is IOC(Inversion of Control) - giving up control to others
Instead of a class controlling it dependencies, an external entity (like a DI container or external
framework) that show dependencies are created or injected.
Without IOC With IOC
Class Engine{} class Car{
Class Car{ private Engine _engine;
Private Engine engine; public Car(Engine engine){
_engine = engine}}
Public Car(){
engine = new Engine();// tightly coupled
}
Benefits of IOC:
Loosely Coupling between components
Better maintainability and testability
DI injection is one of the way to achieve IOC
IServiceCollection is used to register services. Check
extension class
IServiceProvider is used to resolve services. Check hangfire
How Does BuildServiceProvider() Work?
The BuildServiceProvider() method compiles the list of services registered in IServiceCollection and generates an
IServiceProvider. This method takes care of the internal mechanics of service resolution .
Understanding IServiceCollection and IServiceProvider in [Link] Core: A
Complete Guide to Dependency Injection | by parsa panahpoor |
Medium
Why we use Api gateway
Filters:
Request
|
Authorization filters
|
Resource Filters(Model Binding) Resource Filter(OnAction
Executed)
(OnActionExecuting) |
| Action
Filter(OnActionExecuted)
Action Filters |
(OnActionExecuting)
|
Action Execution ---------------------------------------------------------------> Result Filter
AuthorizationFilter: Runs first, check user is authenticated ,if not short circuit the pipeline
Bulit In :OnAuthorize
Implements IAuthorizationFilter(OnAuthorization)
Resource Filter : After Authorization Filter(before model binding), Resource filter
will get executed
UseCase:Ideasl for caching,early request interception
Implementes IResourceFilter(OnResourceExecuting, OnResourceExecuted)
Action Filter : Runs before and after the action method, allowing modification of
input arguments or the result
(validation)
Implements:IActionFilter(OnActionExecuting, OnActionExecuted)
UseCase:Log the execution time of an action method
Exception Filter: Handles unhandled exception thrown during action execution or
result processing.
Implements:IExceptionFilter(OnException)
Result Filter: Runs after action method but before the response is sent , allowing
modification of the result
Implements:IResultFilter(OnResultExecuting, OnResultExecuted)
Endpoint Filter(minimal apis): allow interception and modification of request or response
UseCase: Maniplate User Input
Difference between Encryption and hashing
Encryption : is process of converting readable data (plain text) to unreadable data(ciphertext)
Using a key, with that key only we can decrypt correct key.
Two way process: encrypt -> decrypt
Decrypt -> encrypt
Type Description
Symmetric Same key for encryption & decryption (e.g., AES)
Asymmetric Public key to encrypt, private key to decrypt (e.g., RSA)
Hashing:it is a one way process that input to fixed length string called hash.
One-way process:
You can hash data
you can't unhash data.
Feature Encryption Hashing
Reversible ✅ Yes (with key) ❌ No (one-way)
Purpose Protect data for authorized users Ensure data integrity / verify input
Output Ciphertext Hash value
Use Case Example Secure email, SSL/TLS Password storage, file verification
Example Algorithm AES, RSA SHA-256, bcrypt, MD5
Feature OAuth 2.0 OpenID Connect (OIDC)
Purpose Authorization Authentication + Authorization
Token Type Access Token Access Token + ID Token
User Identity Info? ❌ No ✅ Yes (ID Token contains info)
Who uses it? APIs, third-party services Login systems, identity providers
Built on top of? N/A OAuth 2.0
Top 5 highest distinct salaries:
Select DIStinct salary from employees order by salary desc LIMIT 5;
Or
Select DISTINCT Top 5 salary from employee order by salary desc
Get only N th(N=5) highest salary:
Select Distinct salary from employee order by salary desc limit 1 OFFSET (N-1)
Or
Select Min(salary ) from
(Select Distinct Top 5 salary from Employee order by salary desc) As top5
Or
select salary from (select Distinct salary ,Rank() over (order by salary desc)as rank from employee) where rank = 5
When You want to display employees data whose salary is top 5 th :
With ranked_data as (
Select salary , rank() over (order by salary desc) as rank from employee
)
Select * from employee where salary = (select salary from ranked_data where rank = 5);
with emp_data as(
select [Link],[Link],[Link],[Link] , Rank() over ( order by [Link] desc) as rank from
employee e join dept d on [Link] = [Link]
)
Select * from emp_data whererank = 5
Find managers with more than 10 employees reporting to them
Select [Link], count([Link]) as 'employeeCount' from manager m join employye e on
[Link] =[Link]
Groupby [Link] having Count([Link]) > 10
Third Highest number in an integer array
Int[] arr = {1,2,3,4,5}
[Link]().OrderByDescndingOrder().Skip(2).Take(1);
Diff b/w Value and refetence types
Value type refernce Type
Stores actual data stores reference value
Stores in stack stores in heap
Has its own copy more than variables can refer to some objects
Int,bool,float array,class
Faster slower due to garbage collection
Garbage Collector
garbage collector in .net ie responsbile for automatic memory management
It automatically allocates and disallocates memory for reference types(heap)
Frees the memory that no longer used
Tracks object reference and removes unreferenced object to preventmemory fill
Determine lifetime of object and reclaims the object
GC will take care of managed code.
Feature Managed Data Unmanaged Data
Memory allocation CLR / .NET runtime Manually via OS or native APIs
Memory cleanup Automatic (Garbage Collector) Manual (free, CloseHandle,
etc.)
Safety Type-safe, memory-safe Can cause leaks, crashes, corruption
Common usage .NET classes, arrays, strings File handles, sockets, native libs
Examples string, object, IntPtr, FILE*, Win32 handles
List<int>
Feature IDisposable Finalize (Finalizer / Destructor)
Purpose Manual cleanup of unmanaged Automatic cleanup by Garbage Collector (GC)
resources
Trigger Called explicitly by the developer Called by the GC before object is destroyed
(Dispose)
Performance ✅ Fast, developer-controlled ❌ Slower, non-deterministic, GC overhead
Implementati Implement Override Finalize() (or use
on [Link]() ~ClassName())
method
Recommende ✔️Preferred for resource cleanup ❌ Use only as a fallback (safety net)
d Use
When GC Does not depend on GC Only runs when GC collects the object
runs?
Control Full control when Dispose() is No control — depends on GC schedule
called
Typical Use File handles, DB connections, As a backup to release unmanaged resources if
Case streams Dispose() isn't called
Serilaization and Deserialization:
It is process converting Object to Json – serialization (getting response as c# object into response
json)
It is process of converting json to object – deserialization(while making api call in request body(json)
- model binding(object))
Seralization types
[Link]
If we want to use [Link] add In [Link] file
[Link]().AddJsonOptions(options =>
{
[Link] = [Link];
[Link] = true;
});
[Link]
Add in [Link]
[Link]()
.AddNewtonsoftJson(options =>
{
[Link] = [Link];
[Link] = [Link];
});
Concept Details
Serialization Object → JSON (HTTP response)
Deserialization JSON → Object (HTTP request)
Default serializer [Link]
Customizable? Yes, using options or by switching to [Link]
Used in Model binding (POST/PUT) and response formatting (GET/DELETE)
how to return json or xml in .net core
Two ways to do it
[Link] clients accept header
2. Explicitly configuring the response format
Json
Xml
Request header content-type:application/json
accept:application/xml([Link]().AddXmlSerializerFormatters()😉
We can also force Json or xml , regardless of the request header
How to customize the json formatting?
For [Link]
[Link]().AddJsonOptions(options =>
{
[Link] = [Link]; // covrting
pascal case to camel case
[Link] = true; // pretty print
[Link] = [Link];
});
For [Link] :
install package [Link]
[Link]().AddNewtonsoftJson(options =>
{
[Link] = [Link];
[Link] = [Link];
[Link] = new CamelCasePropertyNamesContractResolver();
});
Feature [Link] [Link]
Indented output WriteIndented = true [Link]
Ignore nulls DefaultIgnoreConditio [Link]
n
Property naming CamelCase CamelCasePropertyNamesContractResolv
er
Custom converters JsonConverter<T> JsonConverter
Reference loop handling ❌ Not supported (basic) ✅ [Link]
What are action filters in web api?
Action filters are run before or after executing if action method , we can alos run custom logic
for Async (IAsyncActionFilter), for sync(IActionFilter)
They are the part of [Link] core pipeline used for
Logging
Validations for inputs
Exception handling
Performance measuring
(we can how much time it takes to complete api call)
Request -> Middleware -> [Action Filter(before)] -> Action Method -> [Action Filter(After)] ->
Response
How to create custom filters?
Custom filters are used to run custom logic before and after execeuting action methods
If synchrounous (inherit ActionFilter- that will implement two methods -> OnActionExcuting ,
OnActionExecuted)
for asynchrous (inherit IAsyncActionFilter – that will implement OnActionExecutionAsync method in
this before logic then await next() then after logic )
Filter
public class MyCustomActionFilter : IActionFilter
{
public void OnActionExecuting(ActionExecutingContext context)
{
[Link]("Action is executing");
}
public void OnActionExecuted(ActionExecutedContext context)
{
[Link]("Action has executed");
}
}
Controller
[ServiceFilter(typeof(MyCustomActionFilter))]
public class HomeController : Controller
{
public IActionResult Index()
{
return View();
}
}
If we want to add filter as attribute to controller or action method we need to inherit
ActionFilterAttribute that implements IResultFilter,IActionFilter
using [Link];
using [Link];
public class MyCustomActionFilter : ActionFilterAttribute
{
public override void OnActionExecuting(ActionExecutingContext context)
{
[Link]("Action is executing");
}
public override void OnActionExecuted(ActionExecutedContext context)
{
[Link]("Action has executed");
}
}
[MyCustomActionFilter] // we can use as attribute as well if we inherit ActionFilterAttribute`
public class HomeController : Controller
{
public IActionResult Index()
{
return View();
}
}
Filter Interface Purpose Can Be Attribute? Common Use Case
ActionFilterAtt Action/Result filter ✅ Yes Pre/post-processing actions
ribute & results
IResourceFilter Resource pipeline ❌ No Early request handling,
caching, etc.
IActionFilter Same as ❌ No (unless Flexible DI and logic
ActionFilterAttribu derived) separation
te
Garbage Collector:
It is automatically manages the memory. It allocates memory for your objects on the managed heap
an periodically cleans up unused ones ..only collects objects that are no longer needed.
Generation:
1 – short lived objects(like local variables)
2 – Medium lifespan
3- Long lived objects
What is Routing?
Map incoming http requests to specific actions
two types of Routing.
Convention-Based Routing:
this are routes defined globally. In [Link] file
ex: [Link](endpoints => [Link]());
when you want to centralized route definitions for multiple controllers without decorating actions
with attributes.
Attribute-based Routing:
Routes are defined directly on controller or action method using attributes like
Route,HttpPost,HttpGet
for minimal Api's
[Link]("/api/products", () => { ... });
[Link]("/api/products/{id}", (int id) => { ... });
Route Paramaters :
it allows you to extract data from URL and pass it to the method arguments
Query string paramaters:
e.g: ?id=1&name=product can be accessed via method parameters by using the
[FormQuery] attribute .
AddKeyedTransient: When you want to implement multiple services to single interface and
rwsolve the same implementation with the key.
Purpose Registers the service with specific key in DI container , with transient failure ( a new
instance is created everytime the service is resolved).
Usecases:
Selecting for different API -Clients( different payment gateways like PayPal or stripe)
choosing environment specific(mock or prod)
Handling feature specific (different logging providers)
[Link]<IAppointmentsService,
AppointmentsV3Service>(ServiceFactoryConstants.AppointmentsV3Service);
in controller
public AppointmentsV3Controller(ILogger<HouseCallDbContext> logger,
[FromKeyedServices("AppointmentsV3Service")] IAppointmentsService
appointmentsService) : base(logger)
{
_appointmentsService = appointmentsService;
}
API Versioning
it is used for maintaing the backward compactability ..building the new api functionality
without breaking the existing functionality.
Different ways to achieve versioning
[Link] path versioning : api versioning is displaying in the URl (e.g., /api/v1/resource or
/v1/api/resource).
This the most common and straight forward approach
[Route("api/v{version:apiVersion}/[controller]")]
[ApiVersion("1.0")]
public class ProductsController : ControllerBase
{
[HttpGet]
public IActionResult Get() => Ok("Product list from API v1.0");
}
[Link] path versioning : api versioning is specifed as the query parameters (e.g.,
/api/resource?api-version=1.0).
[ApiVersion("1.0")]
[ApiVersion("2.0")]
public class ProductsController : ControllerBase
{
[HttpGet]
public IActionResult Get() => Ok("Product list from API v1.0");
[HttpGet, MapToApiVersion("2.0")]
public IActionResult GetV2() => Ok("Product list from API v2.0 with new features");
}
[Link] versioning. : API versioning is specified in the request headers (e.g., X-API-
Version: 1.0) or the Accept header.
[ApiVersion("1.0")]
[ApiVersion("2.0")]
public class ProductsController : ControllerBase
{
[HttpGet]
public IActionResult Get() => Ok("Product list from API v1.0");
[HttpGet, MapToApiVersion("2.0")]
public IActionResult GetV2() => Ok("Product list from API v2.0 with new features");
}
To implement versioning need to add package
dotnet add package [Link]
URL based Header
Versioning
*When you want to clear knowledge and when u don't want
to displaying the version in url by making it clear and more restfu
*When you want to display version in the url. by using the same
url across the versions, reducing the risks of breaking the clients
*Version is visible in the the url Will pass version in
headers
Routing is straightforward we can easily identity in swagger Client must
know include the version in headers
It can break the client integration unless you maintain old versions
Showing versiong in the endpoint making it less restfull
We can configure in [Link] what it needs to use
[Link](option =>
{
[Link] = true; //This ensures if client doesn't specify an API
version. The default version should be considered.
[Link] = new ApiVersion(1, 0); //This we set the default API version
[Link] = true; //The allow the API Version information to be reported in the client in
the response header. This will be useful for the client to understand the version of the API they are
interacting with.
//------------------------------------------------//
[Link] = [Link](
new QueryStringApiVersionReader("api-version"),
new HeaderApiVersionReader("X-Version"),
new MediaTypeApiVersionReader("ver")); //This says how the API version should be read from the
client's request, 3 options are enabled [Link], [Link], [Link].
//"api-version", "X-Version" and "ver" are parameter name to be set with version number in client before
request the endpoints.
}).AddApiExplorer(options => {
[Link] = "'v'VVV"; //The say our format of our version number “‘v’major[.minor][-
status]”
[Link] = true; //This will help us to resolve the ambiguity when there is a
routing conflict due to routing template one or more end points are same.
});