Monday 27 March 2023

The Ultimate Guide to Interceptors: Understanding Their Power and Functionality

 

The Ultimate Guide to Interceptors: Understanding Their Power and Functionality

An interceptor is a service that can intercept HTTP requests and responses. Interceptors provide a way to modify or handle requests and responses globally before they are sent to the server or returned to the client.

Interceptors



Interceptors are used for a variety of tasks such as:

  1. Adding headers to requests or responses
  2. Authentication and authorization of requests
  3. Logging of requests and responses
  4. Caching of requests
  5. Error handling and retrying failed requests
  6. Translating requests and responses to different formats
  7. Transformation of request and response bodies.

Interceptors can be added to the HTTP pipeline by providing them as a provider in the app.module.ts file or at a component level using the provider's property.

Interceptors are implemented as classes that implement the HttpInterceptor interface. The HttpInterceptor interface has two methods:

  1. intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> - This method intercepts the outgoing request and returns an Observable of HttpEvents.

  2. handle(request: HttpRequest<any>): Observable<HttpEvent<any>> - This method handles the outgoing request and returns an Observable of HttpEvents.

The intercept method is called for each outgoing HTTP request and can modify the request or return the original request. The handle method is called for the last interceptor in the chain and is responsible for sending the request to the server.

By using interceptors, developers can write reusable code that can be used across multiple components and services.

 
 

Tuesday 21 March 2023

Mastering Data Filtering with Complex Objects: Strategies and Techniques


Mastering Data Filtering with Complex Objects: Strategies and Techniques


Hi Everyone, The filter logic is a mechanism that allows you to search and retrieve specific data from a larger dataset. The filter function takes two arguments: the data to filter and a filter parameter that defines the search criteria. The function returns a subset of the original data that matches the filter criteria.So lets understand how we can acheive "Data Filtering with Complex Objects".

In the case of the Angular Material table, the filter logic is used to search for specific data in a table by applying a search filter to one or more columns. When the user enters a search query, the filter logic is triggered and filters the table data based on the search criteria. The filtered data is then displayed in the table.

The filter logic can be implemented in many ways, depending on the specific use case.
Now consider this JSON array which contains nested array.


[

{

deviceUUID: ‘80a9b8a2–3a2c’,

ipAddress: ‘2.2.2.67’,

deviceParameter: {

deviceName: ‘device44’,

unitIdentifier: 1,

port: 502,

},

isConnected: false,

isSerial: false,

details: null,

Type: ‘Ethernet’,

},

{

deviceUUID: ‘80a9b8a2–3a2c’,

ipAddress: ‘2.2.2.67’,

deviceParameter: {

deviceName: ‘device46’,

unitIdentifier: 1,

port: 503,

},

isConnected: false,

isSerial: false,

details: null,

Type: ‘Ethernet’,

},

{

deviceUUID: ‘80a9b8a2–3a2c’,

ipAddress: ‘2.2.2.67’,

deviceParameter: {

deviceName: ‘device48’,

unitIdentifier: 1,

port: 505,

},

isConnected: false,

isSerial: false,

details: null,

Type: ‘Ethernet’,

}

];




So if our requirement says that filter the object on ‘device name’ or ‘port’ that is not quite possible because that mat-filter is works with straight forward object but we can also achieve this things first understand how we can do that

The inner object search is different because it requires accessing a nested property within each object of an array, whereas other searches involve searching for a property directly in each object of the array. This requires a different approach to extract the nested property and perform the search.

So here we use ‘ filterPredicate’ to search nested object : The filterPredicate is used to search nested objects in a mat-table because the default filter behaviour in Angular Material only works on flat objects with simple properties. When dealing with more complex data structures like nested objects, we need to write their own custom filtering logic to extract the nested data they want to filter on. The filterPredicate function provides a way to do this by allowing us to write own filtering logic based on the nested data structure of their data source.

So lets begin with our example.


first create a one project which have preinstall angular material and all dependencies that is required to run angular mat-table to run

2. Here is my app.component.html code to declare mat-table

<mat-label>Filter</mat-label>

<input matInput (keyup)=”applyFilter($event)” placeholder=”Ex. ium” #input>

<table mat-table [dataSource]=”dataSource” matSort matSortActive=”deviceName” matSortDirection=”asc” matSortDisableClear>

<ng-container matColumnDef=”deviceName”>

<th mat-header-cell *matHeaderCellDef mat-sort-header> Device Name </th>

<td mat-cell *matCellDef=”let device”> {{device.deviceParameter.deviceName}} </td>

</ng-container>

<ng-container matColumnDef=”unitIdentifier”>

<th mat-header-cell *matHeaderCellDef> Unit Identifier </th>

<td mat-cell *matCellDef=”let device”> {{device.deviceParameter.unitIdentifier}} </td>

</ng-container>

<ng-container matColumnDef=”port”>

<th mat-header-cell *matHeaderCellDef> Port </th>

<td mat-cell *matCellDef=”let device”> {{device.deviceParameter.port}} </td>

</ng-container>

<tr mat-header-row *matHeaderRowDef=”displayedColumns”></tr>

<tr mat-row *matRowDef=”let row; columns: displayedColumns;”></tr>

</table>

3. Replace the component.ts code with this

import { Component } from ‘@angular/core’;

import { MatTableDataSource } from ‘@angular/material/table’;

export interface Device {

deviceUUID: string;

ipAddress: string;

deviceParameter: {

deviceName: string;

unitIdentifier: number;

port: number;

};

isConnected: boolean;

isSerial: boolean;

details: any;

Type: string;

}

const DEVICE_LIST: Device[] = [

{

deviceUUID: ‘80a9b8a2–3a2c’,

ipAddress: ‘2.2.2.67’,

deviceParameter: {

deviceName: ‘device44’,

unitIdentifier: 1,

port: 502,

},

isConnected: false,

isSerial: false,

details: null,

Type: ‘Ethernet’,

},

{

deviceUUID: ‘80a9b8a2–3a2c’,

ipAddress: ‘2.2.2.67’,

deviceParameter: {

deviceName: ‘device46’,

unitIdentifier: 1,

port: 503,

},

isConnected: false,

isSerial: false,

details: null,

Type: ‘Ethernet’,

},

{

deviceUUID: ‘80a9b8a2–3a2c’,

ipAddress: ‘2.2.2.67’,

deviceParameter: {

deviceName: ‘device48’,

unitIdentifier: 1,

port: 505,

},

isConnected: false,

isSerial: false,

details: null,

Type: ‘Ethernet’,

}

];

@Component({

selector: ‘app-root’,

templateUrl: ‘./app.component.html’,

styleUrls: [‘./app.component.css’]

})

export class AppComponent {

title = ‘MaterialDesign’;

displayedColumns: string[] = [‘deviceName’, ‘unitIdentifier’, ‘port’];

dataSource = new MatTableDataSource<Device>(DEVICE_LIST);

constructor() {

// this.dataSource = new MatTableDataSource<Device>(DEVICE_LIST);

this.dataSource.filterPredicate = (data: Device, filter: string) => {

const searchString = filter.trim().toLowerCase();

return data.deviceParameter.deviceName.toLowerCase().includes(searchString) ||

data.deviceParameter.port.toString().toLowerCase().includes(searchString);

};

}

applyFilter(event: Event) {

const filterValue=(event.target as HTMLInputElement).value;

this.dataSource.filter = filterValue.trim().toLowerCase();

}

}




4. Replace the app.module.ts file with following code :


import { NgModule } from ‘@angular/core’;

import { BrowserModule } from ‘@angular/platform-browser’;

import { AppRoutingModule } from ‘./app-routing.module’;

import { AppComponent } from ‘./app.component’;

import { BrowserAnimationsModule } from ‘@angular/platform-browser/animations’;

import { MatSlideToggleModule } from ‘@angular/material/slide-toggle’;

import { MatButtonModule } from ‘@angular/material/button’;

import { MatTableModule } from ‘@angular/material/table’;

import { MatPaginatorModule } from ‘@angular/material/paginator’;

import { MatSortModule } from ‘@angular/material/sort’;

import { MatFormFieldModule } from ‘@angular/material/form-field’;

@NgModule({

declarations: [

AppComponent,

],

imports: [

BrowserModule,

AppRoutingModule,

BrowserAnimationsModule,

MatSlideToggleModule,

MatButtonModule,

MatTableModule,

MatPaginatorModule,

MatSortModule,

MatFormFieldModule

],

providers: [],

bootstrap: [AppComponent]

})

export class AppModule { }

Now understand how this filterPredicate function works. please again review this code


constructor() {

this.dataSource.filterPredicate = (data: Device, filter: string) => {

const searchString = filter.trim().toLowerCase();

return data.deviceParameter.deviceName.toLowerCase().includes(searchString) ||

data.deviceParameter.port.toString().toLowerCase().includes(searchString);

};

}

applyFilter(event: Event) {

const filterValue=(event.target as HTMLInputElement).value;

this.dataSource.filter = filterValue.trim().toLowerCase();

}

The function is being assigned to the filterPredicate property of a MatTableDataSource object.

It takes two arguments: data and filter. data represents a single element in the data source, while filter is the value entered by the user to filter the data.

searchString is a variable that is created by trimming any whitespace and converting the filter string to lowercase.

The function returns a boolean value that determines whether or not the data object should be included in the filtered data source. It does this by checking if the lowercase deviceName or lowercase port of the deviceParameter object of the data object includes the searchString.

If the searchString is found in either deviceName or port, the function returns true, indicating that the data object should be included in the filtered data source.

If the searchString is not found in either deviceName or port, the function returns false, indicating that the data object should be excluded from the filtered data source.

Please feel free to check out my GitHub repository at the following link, where you can find the code for the NestedObjectFilterMatTable:

Filter Nested Complex object

I would greatly appreciate it if you could take a look at it and let me know if you have any feedback or suggestions. Thank you very much for your time and consideration.

Thursday 16 March 2023

Window 11 key available

Windows 11 | Everything You Need to Know About the Latest Version of Windows You can check my previous blog "How to get our current location in formatted text using Angular and google map api"

Hey you can use one of the key to activate your window 11

  • MDNYT-96482-9CB73-7WKQG-FVV26
  • RYGNV-CJ9T7-P8X6Q-DJJ8J-D9MP6
  • 4G6QR-NRJQ8-K69CW-QHCYR-9W3GT
  • WVNPR-3XCR7-MM7X4-8R8XM-2PQGT
  • 3RBJQ-CRNT6-JTFVW-P3BYV-KHJXG
  • VNDG6-FQJ8X-BQWHW-3XV6G-23726
  • GJBNR-DW8RH-THV48-JC3WJ-78RC6

Wednesday 15 March 2023

How to get our current location in formatted text using Angular and google map api

Get Current Location Using Angular and Google Maps API - Step-by-Step Tutorial

Hi Everyone, hope you all are doing well.

  1. Introduction: how web applications that use location data can provide users with more personalized and relevant experiences. For example, a weather app could display the current weather conditions based on the user’s location, or a restaurant review app could show nearby restaurants based on the user’s current location. we can also highlight the benefits of using the Google Maps Geocoding API, such as its accuracy and speed.

a. Create a new Angular project by running the following command in your terminal:
ng new location-app
b. Navigate to the project directory:
cd location-app
c. Open the project in your code editor:
code .
d. In the app.component.html file, add the following code:

<button (click)=”locateMe()”>Locate Me</button>

<br>

<input type=”text” [value]=”address”>

This code creates a “Locate Me” button and an input box to display the formatted address.

e. In the app.component.ts file, add the following code:

import { Component } from ‘@angular/core’;

import { GeocodingService } from ‘./geocoding.service’;

@Component({

selector: ‘app-root’,

templateUrl: ‘./app.component.html’,

styleUrls: [‘./app.component.css’]

})

export class AppComponent {

address = ‘’;

constructor(private geocodingService: GeocodingService) { }

locateMe() {

navigator.geolocation.getCurrentPosition(position => {

const latitude = position.coords.latitude;

const longitude = position.coords.longitude;

this.geocodingService.getAddress(latitude, longitude).subscribe(response => {

this.address = response.results[0].formatted_address;

});

}, error => {

console.log(‘Error: ‘, error);

});

}

}

This code imports the GeocodingService and sets up a locateMe() function that retrieves the user’s current location using the navigator.geolocation API. It then sends a request to the Google Maps Geocoding API using the GeocodingService, and updates the address variable with the formatted address from the response.

f. In the geocoding.service.ts file, add the following code:

import { Injectable } from ‘@angular/core’;

import { HttpClient } from ‘@angular/common/http’;

import { Observable } from ‘rxjs’;

@Injectable({

providedIn: ‘root’

})

export class GeocodingService {

private geocodingApiUrl = ‘https://maps.googleapis.com/maps/api/geocode/json';

constructor(private http: HttpClient) { }

getAddress(latitude: number, longitude: number): Observable<any> {

const url = `${this.geocodingApiUrl}?latlng=${latitude},${longitude}&key=<YOUR_API_KEY>`;

return this.http.get<any>(url);

}

}

This code creates a “GeocodingService” that sends requests to the Google Maps Geocoding API using the user’s latitude and longitude coordinates.

g. Replace <YOUR_API_KEY> in the geocoding.service.ts file with your own Google Maps API key.

h. In the app.module.ts file, add the following code:

import { NgModule } from ‘@angular/core’;

import { BrowserModule } from ‘@angular/platform-browser’;

import { HttpClientModule } from ‘@angular/common/http’;

import { AppComponent } from ‘./app.component’;

import { GeocodingService } from ‘./geocoding.service’;

@NgModule({

declarations: [

AppComponent

],

imports: [

BrowserModule,

HttpClientModule

],

providers: [GeocodingService],

bootstrap: [AppComponent]

})

export class AppModule { }

This code imports the HttpClientModule and the GeocodingService, and sets them up in the providers array.

i. Run the following command to start the development server:

ng serve –open

Now here to understand one point

  • The Google Cloud Console ( https://console.cloud.google.com/) should be accessed.

Note : Before using the API key, it is important to check if the Google Maps JavaScript API has been enabled in the project. To do this, navigate to the “APIs & Services” > “Library” menu item located in the left sidebar and search for “Google Maps JavaScript API.” If it is not enabled, click the “Enable” button to activate it.

Explanation of Code : To retrieve the user’s current position, the getCurrentPosition() method is used. This method takes two callbacks as parameters; the first callback is invoked when the position is successfully retrieved, and the second callback is invoked when an error occurs. Once the position is successfully retrieved, the latitude and longitude values are extracted from the coordinates object. To obtain the formatted address of the user’s current location, the “geocodingService” is utilized. Using the getAddress() method, the latitude and longitude are passed as parameters which in turn returns an observable that emits the response from the Google Maps Geocoding API.

The response from the observable is handled by making use of the subscribe() method. The response object contains an array of results, with each result representing a possible match for the given latitude and longitude. From the first result in the array, the formatted_address string is extracted and assigned to the address property of the component.

For this i am also attaching this project to my git library you can access and try to run with replacing your key that is available on “geocodingService ” File.


https://github.com/upadhyayneeraj90/LocateMe

Monday 13 March 2023

Loom Chrome Extension Causes Console Error While Running Project

Fixing Console Error: Troubleshooting Loom Chrome Extension for Running Projects

Recently, I created a project for my learning. When I ran it using the command “ng-serve -o”, it successfully ran on the browser at “

https://localhost:4200 ". However, it gave me a console error, which is as follows:

    
      Uncaught (
      
      in promise) 
      
      TypeError: 
      
      Cannot convert 
      
      undefined or 
      
      null to 
      
      object
      
at Function. keys (<anonymous>)
at companion-bubble. js: 1465: 19726
at Generator. next (<anonymous>)
at Ln (companion-bubble. js: 1465: 19144)

Upon analyzing the error, I discovered that it was caused by the Loom extension that I had downloaded for video recording on my laptop. Once I removed this extension from my browser, the error disappeared.


Saturday 11 March 2023

This version of CLI is only compatible with Angular versions ^15.0.0, but Angular version 8.1.3 was found instead.

When working on an existing Angular project, I typically review all the project details and execute the "npm install" command in the terminal to install all the necessary modules. However, upon attempting to run the project using a CLI command, an error is displayed.

This version of CLI is only compatible with Angular versions ^15.0.0, but Angular version 8.1.3 was found instead.





 
Following that, I navigated to the project's package.json file and discovered that the project was developed using Angular version 8.1.3.


There are two potential ways to address this issue:


1.       Upgrade your Angular project to a newer version that aligns with the Angular CLI version you have installed.

2.       Downgrade the Angular CLI version to a version that supports your current Angular version.


Let's delve into each of these methods in more detail.

·         upgrade your project to use a newer version of Angular : To upgrade your Angular project, you can follow the steps outlined in the Angular documentation for upgrading to a newer version: https://update.angular.io/

 

General step that to be followed to update the project

a.       Check the compatibility: Review the official Angular documentation to ensure that the version you are upgrading to is compatible with your application.

b.       Update Angular CLI: Update the Angular CLI to the latest version by running the following command in your terminal or command prompt: ng update @angular/cli

c.       Update Angular Core: Update the Angular Core package to the latest version by running the following command in your terminal or command prompt: ng update @angular/core

d.       Update dependencies: Review and update other dependencies in your package.json file, as necessary.

e.       If we are using any third party library let say material and other then we need to be update that with newer version

f.       Fix any errors: Review your application and fix any errors that occur as a result of the updates.

g.        Run tests: Run your application's tests to ensure that everything is working as expected.

h.       Update Angular Language Service: If you are using Angular Language Service, update it to the latest version by running the following command in your terminal or command prompt: ng update @angular/language-service

i.       Update other Angular packages: If you are using any other Angular packages, such as @angular/router or @angular/forms, update them to the latest version by running the appropriate ng update command.


·         downgrade the Angular CLI version : To downgrade the version of our project we can run the following commands on CLI.


npm uninstall -g @angular/cli

 

Then, install a specific version of the CLI that is compatible with your Angular version using the following command:

 

npm install -g @angular/cli@<version>

 

Replace <version> with the version number of the CLI that is compatible with your Angular version, for example:

 

npm install -g @angular/cli@8.1.3

 

After installing the compatible version of the CLI, you should be able to use it with your current version of Angular.

 

In my personal opinion, if you are assign or work with previous version of angular project you must try to downgrade your angular CLI version because sometime upgrading will causing issue because some of the libraries are not compatible with newer version.


Friday 10 March 2023

Essential Concepts for Effective Use of Tableau

 Some of these key concepts we should aware about Tableau:

  1. Data Source: A data source is the location of the data that will be used for analysis and visualization in Tableau. Data sources can include spreadsheets, databases, cloud-based applications, and other sources of data.
  2. Workbook: A workbook is a collection of sheets, dashboards, and stories that are used to create and share visualizations in Tableau.
  3. Sheet: A sheet is a single view within a workbook that displays data as a visualization. Users can create multiple sheets within a workbook to analyze and display different aspects of the data.
  4. Visualization: A visualization is a graphical representation of data that allows users to better understand and analyze it. Tableau offers a range of visualization types, including bar charts, line charts, scatter plots, heat maps, and more.
  5. Calculated Field: A calculated field is a custom formula that users can create to perform calculations and manipulate data within Tableau.
  6. Filter: A filter is used to narrow down the data that is displayed in a visualization. Users can apply filters to a sheet or dashboard to focus on specific subsets of the data.
  7. Dashboard: A dashboard is a collection of visualizations and other components that are combined into a single view. Dashboards can be used to display key metrics and provide an overview of the data.
  8. Story: A story is a sequence of visualizations and other elements that are used to tell a data-driven narrative. Stories can be used to highlight trends, insights, and key findings from the data.

What is Tableau?

 Tableau is a powerful and widely used data visualization and business intelligence software that allows users to connect, analyze, and visualize data in an intuitive and interactive way. It offers a user-friendly interface with drag-and-drop features, making it easy for even non-technical users to create and share visualizations.

Tableau offers a range of visualization types, including bar charts, line charts, scatter plots, heat maps, and more, as well as the ability to create interactive dashboards and stories to help communicate insights and findings. Tableau also allows users to connect to a variety of data sources, including spreadsheets, databases, and cloud-based applications, making it a flexible and versatile tool for data analysis.

Overall, Tableau is a powerful and easy-to-use tool that can help individuals and organizations make sense of complex data sets and gain valuable insights into their business operations, customers, and more.

.NET Core Evolution: A Comparative Analysis of Web API Development from 3.1 to the Latest Versions

 The main difference between .NET Core 3.1 and newer versions of .NET Core (such as .NET 5 and .NET 6) is that .NET Core 3.1 was the last version of .NET Core, while the newer versions have been rebranded as .NET, without the “Core” designation.

we named this new release .NET 5 instead of .NET Core 4 for two reason:

  • To prevent confusion with the .NET Framework 4.x, we intentionally omitted version numbers 4.x. Furthermore, we have removed the term “Core” from the name to highlight that this implementation of .NET is now the primary one
  • With .NET 5, we have expanded our support to encompass more application types and platforms than what was available in either .NET Core or .NET Framework.

However, in terms of features and functionality, there are several differences between .NET Core 3.1 and the newer versions of .NET:

Now we trying to understand what is new in each step that is given above

  • C# updates :
    a. Top-level statements: You can now write code without needing to wrap it in a class or a method. This feature can simplify small programs and make them more concise.
    b. Improved pattern matching: Pattern matching has been improved with the introduction of the “and” and “or” operators, as well as the ability to use patterns in switch expressions.
    c. Records: Records are a new reference type that allow you to create immutable objects with value semantics. Records can simplify code and improve performance in certain scenarios.
    d. Target-typed new expressions: You can now omit the type name in a new expression if the type can be inferred from the context.
    e. Covariant returns: You can now override a method with a return type that is more derived than the return type of the overridden method. This can make it easier to work with interfaces and base classes.
    f. Init-only properties: You can now declare properties that can only be set during object initialization. This can help enforce immutability and make code more readable.
    g. Performance improvements: C# 9 includes several performance improvements, such as better JIT performance, faster string handling, and more efficient collection initialization.
  • F# update : because I am using c# in .net application but you still want to what is change in F# you can refer this link https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-5#f-updates
  • Visual Basic updates : https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-5#visual-basic-updates
  • System.Text.Json new features : System.Text.Json is a JSON serialization and deserialization library that was introduced in .NET Core 3.0 and has been further improved in .NET 5. Here are some of the new features and improvements in System.Text.Json in .NET 5:
    1. Support for a wider range of types: System.Text.Json now supports serialization and deserialization of more types, including enums, nullable value types, and types with read-only properties.
    2. Improved performance: The library has been optimized for better performance, with faster serialization and deserialization speeds than in previous versions.
    3. More customization options: You can now customize how objects are serialized and deserialized, such as by renaming properties, ignoring properties, or applying custom converters.
    4. Support for reference handling: System.Text.Json now supports reference handling, which can help reduce the size of JSON payloads and improve performance in certain scenarios.
    5. Improved error handling: The library now provides more detailed error messages when serialization or deserialization fails, making it easier to debug issues.
    6. Support for UTF-8 and UTF-16 encoding: You can now choose to serialize JSON data in either UTF-8 or UTF-16 encoding, depending on your needs.
  • Single file apps : Single file apps were introduced in .NET Core 3.0 and have been further improved in .NET 5. Here are some of the new features and improvements in single file apps in .NET 5:
    * Cross-platform support: Single file apps can now be created and run on Windows, Linux, and macOS, making them even more versatile.
    * Improved performance: The startup time for single file apps has been improved, with faster app launch times than in previous versions.
    * Support for native libraries: You can now package native libraries alongside your .NET assemblies in a single file app, allowing you to create self-contained apps that can be run without installing any dependencies on the target machine.
    * More deployment options: You can deploy single file apps using a variety of methods, including HTTP download, network share, or USB drive.
    * Reduced file size: The size of single file apps has been reduced, making it easier to distribute and deploy them.
    * Improved debugging experience: Single file apps can now be debugged in Visual Studio and other debugging tools, making it easier to diagnose issues during development.
  • App trimming: Application trimming is a feature in .NET that reduces the size of an application by removing unused code during the build process. This feature was introduced in .NET Core 3.0 and has been further improved in .NET 5. Here are some of the new features and improvements in application trimming in .NET 5:
    1. Improved analysis: The analysis process has been improved to better understand how your application is being used, and to identify code that can be safely removed.
    2. Faster build times: The analysis and trimming process has been optimized for faster build times, which can help improve developer productivity.
    3. More precise trimming: The trimming process now takes into account the specific runtime environment in which the application will run, allowing for more precise trimming that does not remove code that is actually used.
    4. Better support for reflection: Reflection is now better supported in trimmed applications, allowing for more accurate analysis of the code that is actually used at runtime.
    5. Improved compatibility: The trimming process has been improved to ensure compatibility with third-party libraries and frameworks, reducing the risk of breaking changes when applications are trimmed.
    6. Support for conditional trimming: You can now specify which parts of your application should be trimmed based on conditions such as the target platform or runtime environment.

Rest of the point is general and you can try to read this with following url


https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-5


hope you like this

AdSense

The Ultimate Guide to Interceptors: Understanding Their Power and Functionality

  The Ultimate Guide to Interceptors: Understanding Their Power and Functionality An interceptor is a service that can intercept HTTP reques...

Follow