Magic Shilla App 📌

❤ I have missed the code Net core

Give a Star! ⭐

If you like or are using this project to learn or start your solution, please give it a star. Thanks!

Technical Dictionary

🧨 Binding Parameters in Asp.Net MVC

FromQuery :
This type contains query items. To use them, we need to read parameters from URL address and we need to check ? character. Example https://example.com/api/products?id=123&name=keyboard
```
[HttpGet("products")]
public IActionResult GetProduct([FromQuery] int id, [FromQuery] string name)
{

}
```
FromBody :
This type uses data inside of HTTP Body. it generally used for POST, PUT or PATCH requests. Kind of data might be JSON, XML or another type.
```
[HttpPost("products")]
public IActionResult CreateProduct([FromBody] ProductDto productDto)
{
   
}
```
FromRoute :
It is used to bind routing parameters in the URL to a parameter in the API method. Redirect parameters are dynamic values specified in a specific part of the URL. Example https://example.com/api/products/{id} It is commonly used when reading resource id information.
```
[HttpGet("products/{id}")]
public IActionResult GetProductById([FromRoute] int id)
{
}
```

🧨 Validation

🧨 Region Directive

I am particularly fond of 😻 the #region directive. It allows us to collapse code in a customized manor. Regions are created in this format,

#region NisanurStartedCoding
return Ok(👌);
#endregion

Benefits of using region director :

Well organized
easily readable
code can be easily navigated
increade efficiency

Dapper vs Entity FrameWork

IEnumerable vs IQueryable

🧨 Differences Between Scoped, Transient, And Singleton Service

Why we require

It defines the lifetime of object creation or a registration in the .net core with the help of Dependency Injection.
The DI Container has to decide whether to return a new object of the service or consume an existing instance.
The lifetime of the Service depends on how we instantiate the dependency.
We define the lifetime when we register the service.

Three types of lifetime and registration options

Scoped
Transient
Singleton

Scoped

In this service, with every HTTP request, we get a new instance.
The same instance is provided for the entire scope of that request.
- eg., if we have a couple of parameter in the controller, both object contains the same instance across the request
This is a better option when you want to maintain a state within a request.

services.AddScoped<IAuthService,AuthService>();

Transient

A new service instance is created for each object in the HTTP request.
This is a good approach for the multithreading approach because both objects are independent of one another.
The instance is created every time they will use more memory and resources and can have a negative impact on performance
Utilize for the lightweight service with little or no state.

services.AddTransient<ICronJobService,CronJobService>();

Singleton

Only one service instance was created throughout the lifetime.
Reused the same instance in future, wherever the service is required
Since it's a single lifetime service creation, memory leaks in these services will build up over time.
Also, it has memory efficient as they are created once reused everywhere.

services.AddSingleton<ILoggingService, LoggingService>();

When to use which Service

Singleton approach => We can use this for logging service, feature flag(to on and off module while deployment), and email service

Scoped approach => This is a better option when you want to maintain a state within a request.

Transient approach => Use this approach for the lightweight service with little or no state.

🔍 AsNoTracking:

in scenarios where you only need read-only access to data and don't intend to modify or update it, using AsNoTracking can offer performance benefits.

💡 It avoids the overhead of change tracking, resulting in faster query execution.

🔍 AsNoTrackingWithIdentity:

When using AsNoTrackingWithIdentity, EF Core still tracks the identity of entities retrieved from the database.

💡 It is particularly useful when working with scenarios that require a mix of read-only and update operations

📌 Key Differences:

AsNoTracking completely disables change tracking, resulting in improved performance for read-only scenarios
AsNoTrackingWithIdentity disables change tracking for most properties, but it keeps track of the entity's identity, allowing updates to be applied efficiently when necessary.

🔧 When to Use Which ❓ when should you use each method ❓

Use AsNoTracking when you only require read-only access to entities and want to optimize performance.
Use AsNoTrackingWithIdentity when you need both read-only access and the ability to update specific entities efficiently.

Data Transfer Objects are used to transfer data between the Application Layer and the Presentation Layer.

💡 Layouts

Layout actually used to maintain consistency in the web pages and also using this, repetitive code can be reduced. Normally, layout mainly contains header, navigation, menu elements or footer sections.

💡 Partial Views

Partial views mainly reduce code duplicate by maintain reusable parts of the views.

💡 View Components

It is quite similar to the partial view in terms of reusability and reduce code repetition.

View components do not use model binding
View Component class must be derived from the ViewComponent class.
Like Partial View, View components does not depend on controllers. It has its own class to implement the logic to develop the component’s model and razor markup view page.
View Components can utilize dependency injection

Actually, views help us to establish a SOC Design (Separation of Concerns) within the MVC application. It basically separates the user interface from other parts of the application.

Packages	Links	References
Microsoft.AspNetCore.JsonPatch Microsoft.AspNetCore.Mvc.NewtonsoftJson Serilog.AspNetCore Serilog.Sinks.File Microsoft.EntityFrameworkCore.SqlServer Microsoft.EntityFrameworkCore.Tools AutoMapper.Extensions.Microsoft.DependencyInjection AutoMapper Microsoft.AspNetCore.Mvc.Versioning.ApiExplorer/5.1.0 Microsoft.AspNetCore.Identity.EntityFrameworkCore	What is JSON Patch? Generate Fake C# Data 10-bad-practices-to-avoid-in-aspnet-core-api-controllers	differences-between-scoped-transient-and-singleton-service explaining-difference-between-asnotracking-net-core Data-Transfer-Objects Dapper v/s Entity Framework(Core) IEnumerable vs IQueryable Udemy Course RESTful Web API - The Complete Guide (.NET7 API) Part 1

Architecture Patterns	Speed Up API Performance Methods

NisanurBulut / Shilla