Dependency management is a key feature of NuGet. It may be simple to manage dependencies for a single project. As multi-project solutions expand in size and complexity, maintaining dependencies can become difficult.

NuGet's central package management (CPM) features allow you to manage shared dependencies for multiple projects from a single, convenient location.

NuGet package dependencies
NuGet package dependencies have been managed in the following methods.

• packages.config: An XML file used by earlier project types to keep track of the packages that were referenced.
• <PackageReference />: NuGet package dependencies are described by an XML element used in MSBuild projects.

Enabling Central Package Management
You must create a Directory.Packages.props file at the root of your repository and set the MSBuild value ManagePackageVersionsCentrally to true in order to begin using central package management.

Then, using <PackageVersion /> elements that identify the package ID and version, you declare each of the corresponding package versions needed for your projects inside.
<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
    <PackageVersion Include="{{package name}}" Version="{{version number}}" />
  </ItemGroup>
</Project>

For each of the projects, we need to define package references, and each of the projects belongs to the same version.
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="{{package name}}" />
  </ItemGroup>
</Project>

You're controlling your versions centrally and utilizing central package management now!

Let’s check with the demo.
Create one application for whatever you want for the project. Here I have created the console application for demo purposes. In the above image, CPMDemo is the console application, and CPMDemo.Utility is the class library project.

We can create Directory.Packages.props is the root-level file in our console application.

Here is the content of the directory package file.
<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
    <PackageVersion Include="Newtonsoft.Json" Version="13.0.1" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="6.0.27" />
  </ItemGroup>
</Project>

Here is the content of the CPMDemo.csproj changes.
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" />
    <PackageReference Include="Microsoft.EntityFrameworkCore" />
  </ItemGroup>
</Project>

Here is the content of the CPMDemo.Utility.csproj changes.
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" />
    <PackageReference Include="Microsoft.EntityFrameworkCore" />
  </ItemGroup>
</Project>

Once you have completed the above changes on your application side, you just need to build the solution, and then after expanding the dependencies and expanding the packages as well, you will see the packages have been added to your application with the mentioned package versions.

Below is a screenshot taken before building the solution, so at that time we hadn’t added any packages to our application.

Below is a screenshot after building the solution and being able to see the added packages in our application.

Central Package Management rules
There are several restrictions governing the location of the Directory.Packages.props file within a repository's directory as well as its context. For the sake of simplicity, each project is evaluated using a single Directory.Packages.props file.

This indicates that the file nearest to the directory of your project will be considered for it if you have several Directory.Packages.props files in your repository. This gives you additional authority over your repository at different levels.

Repository structure
As an illustration, look at the repository structure below:

Here is the explanation for better understanding.

• ProjectName1 will assess the Directory.Packages.props file in the Repository Name\Solution1\ directory.
• ProjectName2 will assess the Directory.Packages.props file in the Repository Name\ directory.

In this manner, we can concentrate the packages that we need on the application side. It will also be simple to maintain—we just need to change one location, and it will reflect everywhere.

Happy learning!!

To generate a QR code with text surrounding it in ASP.Net, use the nuget package listed below. We can use zxing.net or the QRCoder free nuget package. In this case, we'll use the QRCoder package.

Install the QRCoder package on our project. We are good to go now.

Generate QR Code Sample
In Below code snippet we are using QRCodeGenerator Class to generate QRCode, create an instance for QRCodeGenerator(),
QRCodeData qrCodeData = qrGenerator.CreateQrCode(text, QRCodeGenerator.ECCLevel.Q)

It will Create QRCode Data for the given text.

ECCLevel
Error Correction Level of the QR code. It represents the ability of the QR code to remain readable even if it's partially damaged or obscured.
  L (Low): About 7% of the codewords can be restored.
  M (Medium): About 15% of the codewords can be restored.
  Q (Quartile): About 25% of the codewords can be restored.
  H (High): About 30% of the codewords can be restored.

It will create QRCode for QR Code data,
QRCode qrCode = new QRCode(qrCodeData);

Converting QR Code into bitmap
GetGraphic(int x);

x: Pixel rate for that QR Code
And we have plenty of override methods for GetGraphic() for different use case scenarios.
Bitmap bitMap = qrCode.GetGraphic(20)

Converting bitmap to base64 string
In bitMap.Save() helps us to save the bitmap in image format.

System.Drawing.Imaging.ImageFormat: we can choose which format we would like to save our image, like (PNG, GIF, JPEG, Icons....etc).

And we are converting our memorystream to byte array then we can convert it into string with base64.
System.IO.MemoryStream ms = new System.IO.MemoryStream();
bitMap.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
byte[] byteImage = ms.ToArray();
string base64String = Convert.ToBase64String(byteImage);

Generate Url for QR Code Image
We can define data while returning from API calls, or we can handle that on the UI side.
ImageUrl = "data:image/png;base64," + base64String;

If we just return base64String.
<img  [src]="'data:image/png;base64,'+ base64String" />

Sample for Generate QR Code with text around it.
In Below Sample GetGraphic(7, Color.Black, Color.White, null, 7, 3).

Bitmap GetGraphic(int pixelsPerModule, Color darkColor, Color lightColor, Bitmap icon = null, int iconSizePercent = 15, int iconBorderWidth = 6, bool drawQuietZones = true).
  7: pixelsPerModule
  Black: darkColor
  White: lightColor
  null: icon
  7: iconSizePercent
  3: iconBorderWidth

public string GenerateRecurringQRCode(string key){
string result = string.Empty;
QRCodeGenerator qrGenerator = new QRCodeGenerator()
QRCodeData qrCodeData = qrGenerator.CreateQrCode(key, QRCodeGenerator.ECCLevel.Q)
using (QRCode qrCode = new QRCode(qrCodeData))
{
    using (Bitmap bitMap = qrCode.GetGraphic(7, Color.Black, Color.White, null, 7, 3))
    {
        using (MemoryStream ms = new MemoryStream())
        {
            Bitmap qrCodeWithText = AddTextToQRCode(bitMap); // Adding Text to QR Code
            qrCodeWithText.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
            byte[] byteImage = ms.ToArray();
            result = Convert.ToBase64String(byteImage);
        }
    }
}
return result;
}

In this code snippet below we have drawn a DO NOT SCREENSHOT QR CODE around qr code AddTextToQRCode();
static Bitmap AddTextToQRCode(Bitmap bitMap)
 {
     RectangleF rectf1 = new RectangleF(26, 8, 350, 100);
     RectangleF rectf2 = new RectangleF(26, 263, 350, 100);


     Graphics g = Graphics.FromImage(bitMap);

     g.SmoothingMode = SmoothingMode.AntiAlias;
     g.InterpolationMode = InterpolationMode.HighQualityBicubic;
     g.PixelOffsetMode = PixelOffsetMode.HighQuality;

     g.DrawString("DO NOT SCREENSHOT QR CODE", new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, rectf1);
     g.DrawString("DO NOT SCREENSHOT QR CODE", new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, rectf2);


     Rectangle recleft = new Rectangle();
     recleft.Height = 200;
     recleft.Width = 500;
     recleft.X = 0;
     recleft.Y = 0;
     SizeF s;
     String str = "DO NOT SCREENSHOT QR CODE";
     StringFormat strf = new StringFormat();
     strf.Alignment = StringAlignment.Center;
     recleft.X = 0;
     recleft.Y = 0;
     g.TranslateTransform(8, 393);
     g.RotateTransform(-90);
     g.DrawString(str, new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, recleft, strf);
     g.ResetTransform();

     Rectangle recright = new Rectangle();
     recright.Height = 200;
     recright.Width = 500;
     recright.X = 0;
     recright.Y = 0;
     SizeF sright;
     String strright = "DO NOT SCREENSHOT QR CODE";
     StringFormat strfright = new StringFormat();
     strf.Alignment = StringAlignment.Center;
     recright.X = 0;
     recright.Y = 0;
     g.TranslateTransform(280, -104);
     g.RotateTransform(90);
     g.DrawString(str, new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, recright, strf);
     g.ResetTransform();


     g.Flush();
     return bitMap;
 }

let Break down the above code snippet.

In this, we have created to rectangle to place our text top and bottom
RectangleF rectf1 = new RectangleF(x, y, width, height);
RectangleF rectf1 = new RectangleF(26, 8, 350, 100);

  The X-coordinate of the top-left corner of the rectangle is 26.
  The Y-coordinate of the top-left corner of the rectangle is 8.
  The width of the rectangle is 350.
  The height of the rectangle is 100.

RectangleF rectf1 = new RectangleF(26, 8, 350, 100);
RectangleF rectf2 = new RectangleF(26, 263, 350, 100);

Converting bitmap to graphics and setting quality

• SmoothingMode: This mode helps to smooth the edges of rendered shapes, resulting in a higher quality appearance, especially when drawing lines or curves.
• InterpolationMode: The object will interpolate (or estimate) colors and shapes when scaling or rotating images. HighQualityBicubic typically produces smoother results compared to other interpolation modes.
• PixelOffSetMode: This mode determines how pixels are offset during rendering operations, which can affect the positioning and clarity of rendered objects.

Graphics g = Graphics.FromImage(bitMap);

g.SmoothingMode = SmoothingMode.AntiAlias;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.PixelOffsetMode = PixelOffsetMode.HighQuality;

Draw String in red color and a bold Arial Black font at the positions defined by rectf1 and rectf2 on the QR code image.
void DrawString(string s, Font font, Brush brush, RectangleF layoutRectangle)
  s: "DO NOT SCREENSHOT QR CODE"
  Font: new Font("Arial Black", 10, FontStyle.Bold) We are using Arial Black font and font size 10, fontstyle bold
  Brush: Color of the text we are about to paint (RED)
  layoutRectangle: position and size to a rectangle.

g.DrawString("DO NOT SCREENSHOT QR CODE", new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, rectf1);
g.DrawString("DO NOT SCREENSHOT QR CODE", new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, rectf2);

In this, we have created a rectangle to place our text left and right.

In the code snippet below, we have placed text on the left.
  Rectangle recleft = new Rectangle();: This line creates a new Rectangle object named recleft.
  recleft.Height = 200;: Sets the height of the rectangle to 200.
  recleft.Width = 500;: Sets the width of the rectangle to 500.
  String str = "DO NOT SCREENSHOT QR CODE";: Initializes a string variable str with the text "DO NOT SCREENSHOT QR CODE".
  StringFormat strf = new StringFormat();: Creates a new StringFormat object named strf.
  strf.Alignment = StringAlignment.Center;: Sets the alignment of the text to center.
  recleft.X = 0;: Resets the X-coordinate of the rectangle to 0 (this seems redundant as it was set earlier).
  recleft.Y = 0;: Resets the Y-coordinate of the rectangle to 0 (again, redundant).
  g.TranslateTransform(8, 393);: Translates the origin of the graphics object by (8, 393) pixels or moves the origin of the drawing surface to a specified point.
  g.RotateTransform(-90);: Rotates the graphics object counterclockwise by 90 degrees.
  g.DrawString(str, new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, recleft, strf);: Draws the string str using a specified font, brush, and rectangle. The text is drawn with the previously set rotation and translation.
  g.ResetTransform();: Resets the transformation matrix of the graphics object to its identity matrix, undoing the translation and rotation applied earlier.

Rectangle recleft = new Rectangle();
recleft.Height = 200;
recleft.Width = 500;
recleft.X = 0;
recleft.Y = 0;
String str = "DO NOT SCREENSHOT QR CODE";
StringFormat strf = new StringFormat();
strf.Alignment = StringAlignment.Center;
g.TranslateTransform(8, 393);
g.RotateTransform(-90);
g.DrawString(str, new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, recleft, strf);
g.ResetTransform();

let do the same for right side.
Rectangle recright = new Rectangle();
recright.Height = 200;
recright.Width = 500;
recright.X = 0;
recright.Y = 0;
String strright = "DO NOT SCREENSHOT QR CODE";
StringFormat strfright = new StringFormat();
strf.Alignment = StringAlignment.Center;
g.TranslateTransform(280, -104);
g.RotateTransform(90);
g.DrawString(str, new Font("Arial Black", 10, FontStyle.Bold), Brushes.Red, recright, strf);
g.ResetTransform();

Flushes any pending graphics operations to ensure that all drawing operations are completed and return bit map to GenerateQRCode() method.
g.Flush();
return bitMap;

Note. If you like to change text you need to alter rectangle and size.
Hope this will be helpful.

What is Authentication in the.NET Core API?
Authentication is one of the most fundamental aspects of software development. It secures our APIs and refuses API requests if an unauthorized user attempts to access secure endpoints.

Why do we need Authentication in .Net Core API?

• Data Protection: APIs frequently expose access to data or services that could be abused if they fall into the wrong hands. Authentication ensures that only authorized people or systems can access this information or service.
• Access Control: Not all users should have equal access rights. Some users may have complete access, while others may have limited permissions. Authentication is the initial step in building such an access control mechanism.
• Non-repudiation: Using proper authentication, actions may be traced back to the user who conducted them. This ensures accountability for activities taken, which is necessary in many applications.
• Compliance: Many sectors have standards and obligations in place to protect data and privacy. Authentication, together with other security procedures, helps to meet these regulatory compliance requirements.
• User Experience: By authenticating users, APIs can also provide personalized experiences, as they know who is making the request and can tailor responses accordingly.

Let's Begin
Let's create a new project

Following the API construction, we will install the nuget package "Microsoft.AspNetCore.Authentication.JwtBearer".

For Authentication, we will be using Okta; Okta provides a way to manage and provide access to users and gives its developer platform to try out authentication stuff.

Sign up on the below link

https://developer.okta.com/signup/

Use authO options, and pick up the region of your choice.
After that, we will create a new API, and In the identifier, we usually give out the hosted app URL, but here for testing purposes. We will give our localhost url of our API.

Now click on the APIs on the left side and click on the Test section; you will get the curl command to generate the Okta auth token.

Now let's open our Program.cs, and we will add the following code.
builder.Services.AddAuthentication(options =>

  {
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;

  }).AddJwtBearer(options =>

  {
    options.Authority = "https://dev-7fjgp6661wzrvpqw.us.auth0.com/";
    options.Audience = "https://localhost:7294";

  });

From the values in Okta portal, we can use it in the Postman to get the token response.

Now we will add a new controller in our API called "AllowAllController".
[Route("api/[controller]")]
[ApiController]

public class AllowAllController: ControllerBase {
  [HttpGet]
  public string Get() {
    return "Working okay";
  }
}

Once we run the API and hit this endpoint, we will get the response.

Now to test authorization, we will add a [Authorize] keyboard at the top of the controller.

So now our modified controller looks like this.
[Route("api/[controller]")]
[ApiController]
[Authorize]

public class AllowAllController: ControllerBase
{
  [HttpGet]
  public string Get()
  {
    return "Working okay";
  }
}

Now when we hit our API, it will get the Unauthorized response.

Now we will pass the token we get from the token endpoint in the Authorization Header of the request.

ASP.NET Core is a sophisticated framework for developing online APIs that enables developers to build strong and scalable applications. One of the most important aspects of current web development is the use of third-party APIs, which give access to external services and data.

Create a Model

using System.Text.Json.Serialization;

namespace _1_3rdAPIIntegrationInAspNetCoreWebAPI.Models
{
    public class Product
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Description { get; set; }
        public decimal Price { get; set; }
        public double DiscountPercentage { get; set; }
        public double Rating { get; set; }
        public int Stock { get; set; }
        public string Brand { get; set; }
        public string Category { get; set; }
        public string Thumbnail { get; set; }
        public List<string> Images { get; set; }
    }
}

Here's a breakdown of each property.

• ID: An integer representing the unique identifier of the product.
• Title: A string representing the title or name of the product.
• Description: A string representing the description or details of the product.
• Price: A decimal representing the price of the product.
• DiscountPercentage: A double representing the discount percentage applied to the product.
• Rating: A double representing the rating of the product (e.g., star rating).
• Stock: An integer representing the available quantity of the product in stock.
• Brand: A string representing the brand or manufacturer of the product.
• Category: A string representing the category or type of the product.
• Thumbnail: A string representing the URL or path to the thumbnail image of the product.
• Images: A list of strings representing the URLs or paths to additional images of the product.

Create the Interface for the Product Service
using _1_3rdAPIIntegrationInAspNetCoreWebAPI.Models;

namespace _1_3rdAPIIntegrationInAspNetCoreWebAPI.Interfaces
{
public interface IProducts
{
    Task<List<ProductsResponse>> GetProductsAsync();
}
}

GetProductsAsync: This function returns a Task<List<ProductsResponse>>. It indicates that implementing classes will enable the asynchronous retrieval of a list of products. The List<ProductsResponse> contains product responses, including IDs, titles, descriptions, and pricing. The method is asynchronous, as shown by the Task return type, which means that it can be anticipated for asynchronous execution.

Create the service for the products
using _1_3rdAPIIntegrationInAspNetCoreWebAPI.Interfaces;
using _1_3rdAPIIntegrationInAspNetCoreWebAPI.Models;
using System.Net;
using System.Text.Json;

namespace _1_3rdAPIIntegrationInAspNetCoreWebAPI.Services
{
public class ProductService : IProducts
{
    private static readonly HttpClient httpClient;

    static ProductService()
    {
        httpClient = new HttpClient()
        {
            BaseAddress = new Uri("https://dummyjson.com/")
        };

    }

    public async Task<List<ProductsResponse>> GetProductsAsync()
    {
        try
        {
            var url = string.Format("products");
            var result = new List<ProductsResponse>();
            var response = await httpClient.GetAsync(url);

            if (response.IsSuccessStatusCode)
            {
                var stringResponse = await response.Content.ReadAsStringAsync();
                var productsResponse = JsonSerializer.Deserialize<ProductsResponse>(stringResponse, new JsonSerializerOptions()
                {
                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                });

                // Add the deserialized ProductsResponse to the result list
                result.Add(productsResponse);
            }
            else
            {
                if (response.StatusCode == HttpStatusCode.NotFound)
                {
                    throw new Exception("Products not found.");
                }
                else
                {
                    throw new Exception("Failed to fetch data from the server. Status code: " + response.StatusCode);
                }
            }

            return result;

        }
        catch (HttpRequestException ex)
        {
            throw new Exception("HTTP request failed: " + ex.Message);
        }
        catch (JsonException ex)
        {
            throw new Exception("JSON deserialization failed: " + ex.Message);
        }
        catch (Exception ex)
        {
            throw new Exception("An unexpected error occurred: " + ex.Message);
        }
    }
}
}

Create the Controller for the Products
using _1_3rdAPIIntegrationInAspNetCoreWebAPI.Interfaces;
using _1_3rdAPIIntegrationInAspNetCoreWebAPI.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace _1_3rdAPIIntegrationInAspNetCoreWebAPI.Controllers
{
[Route("api/[controller]/[action]")]
[ApiController]
public class ProductsController : ControllerBase
{
    private readonly IProducts _productService;

    public ProductsController(IProducts productService)
    {
        _productService = productService;
    }

    [HttpGet]
    public async Task<IEnumerable<ProductsResponse>> GetProducts()
    {
        return await _productService.GetProductsAsync();
    }
}
}

Register the Services in IOC Container
using _1_3rdAPIIntegrationInAspNetCoreWebAPI.Interfaces;
using _1_3rdAPIIntegrationInAspNetCoreWebAPI.Services;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddSingleton<IProducts, ProductService>();

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Output

Prompt engineering

For conversational AI systems to be effective, prompt engineering is essential. We'll examine how to apply rapid engineering with.NET Core, a flexible framework for creating cross-platform apps, in this practical course. In order to demonstrate several prompt engineering strategies, such as contextual prompts, error management, and response variation, we'll develop a basic chatbot application.

Setting up your development environment
Before we begin, ensure you have the .NET Core SDK installed on your system. You can download it from the official .NET website

Once installed, open your terminal or command prompt and run the following command to verify the installation.
dotnet --version

If the installation was successful, you should see the version of .NET Core.

Creating a new .NET core console application
Let's start by creating a new .NET Core console application. Open your terminal or command prompt and navigate to the directory where you want to create the project. Then, run the following command.
dotnet new console -n ChatbotApp

This command creates a new console application named "ChatbotApp."
Building the Chatbot

Now that we have our project set up, let's build the chatbot functionality. Open the Program.cs file in your preferred code editor and replace the existing code with the following.
using System;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Welcome to the Chatbot!");
        Console.WriteLine("What's your name?");
        string userName = Console.ReadLine();
        Console.WriteLine($"Hello, {userName}! How can I assist you today?"); // Your prompt engineering logic goes here
    }
}

This code prompts the user for their name and greets them accordingly. Let's add some prompt engineering logic to provide a more interactive experience.

Implementing prompt engineering

• Contextual Prompts: Based on the user's input, we can tailor the prompts to provide relevant responses. For example, if the user asks for help, we can provide assistance prompts.
• Error Handling: Handle user input errors gracefully. If the user provides invalid input, prompt them to try again.
• Response Variation: Introduce a variety of responses to make the conversation feel more natural and engaging.

Here's an example of how you can enhance the chatbot with these prompt engineering techniques.
using System;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Welcome to the Chatbot!");
        Console.WriteLine("What's your name?");
        string userName = Console.ReadLine();
        Console.WriteLine($"Hello, {userName}! How can I assist you today?");

        // Continuously prompt the user for input
        while (true)
        {
            string userInput = Console.ReadLine().ToLower();

            // Handle specific user inputs
            if (userInput.Contains("help"))
            {
                Console.WriteLine("Sure, I can help you with that!");
                continue;
            }
            else if (userInput.Contains("quit") || userInput.Contains("exit"))
            {
                Console.WriteLine("Goodbye! Have a great day!");
                break;
            }

            // Default response for other inputs
            Console.WriteLine("I'm sorry, I didn't understand. Can you please rephrase?");
        }
    }
}

Running the Chatbot

To run the chatbot, navigate to the project directory in your terminal or command prompt and execute the following command.
dotnet run

You'll see the chatbot welcome message and prompt for the user's name. Then, you can interact with the chatbot by entering different inputs and observing the prompt engineering logic in action.

In this hands-on tutorial, we explored prompt engineering using .NET Core by building a simple chatbot application. We implemented various prompt engineering techniques, including contextual prompts, error handling, and response variation, to create an engaging conversational experience. By mastering prompt engineering with .NET Core, you can develop conversational interfaces that provide seamless interactions and enhance user engagement.

Start experimenting with prompt engineering in your .NET Core projects today and unleash the full potential of conversational AI systems.

Keyed services are a major improvement to the built-in dependency injection (DI) framework of.NET 8. This functionality, which has long been a part of third-party DI frameworks like Autofac and StructureMap, gives developers more freedom and control over how dependencies are delivered to their applications. Now let's explore keyed services in more detail: Understanding Keyed Services

In the past,.NET DI registered services exclusively on the basis of their kind. Although this worked well in most cases, it became less successful when there were several implementations of the same interface. This is mitigated by keyed services, which enable us to link a special "key" to every service registration. An enum, string, or any other item that specifically defines the intended implementation can be used as this key.

Advantages of Services with Keys

• Flexibility: You can inject particular implementations according to runtime circumstances, configuration settings, or dynamic conditions.
• Decoupling: Implement different versions of the same interface for distinct uses to keep concerns apart.
• Maintainability: Clearly name and reference desired dependencies in your code to improve readability.
• Configurability: Apply several implementations according to configuration files or environment variables.

Consider a scenario where an application requires data storage because of configuration settings or user preferences. We have two implementations of the IDataStore interface: LocalStorage and CloudStorage.

1. Explain interfaces
public interface IDataStore
{
    void SaveData(string data);
}

public class LocalStorage : IDataStore
{
    public void SaveData(string data)
    {
        // Implementation to save data locally
        Console.WriteLine($"Saving data locally: {data}");
    }
}

public class CloudStorage : IDataStore
{
    public void SaveData(string data)
    {
        // Implementation to save data in the cloud
        Console.WriteLine($"Saving data in the cloud: {data}");
    }
}

2. Register Services with Keys
// In Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<IDataStore, LocalStorage>(key: "local");
    services.AddSingleton<IDataStore, CloudStorage>(key: "cloud");
}

3. Inject and Use Keyed Service
public class MyService
{
    private readonly IKeyedServiceProvider _provider;
    private readonly IConfiguration _configuration;

    public MyService(IKeyedServiceProvider provider, IConfiguration configuration)
    {
        _provider = provider;
        _configuration = configuration;
    }

    public void DoSomething()
    {
        string storageType = _configuration["StorageType"]; // e.g., "local" or "cloud"

        IDataStore store = _provider.GetKeyedService<IDataStore>(storageType);
        store.SaveData("This data will be saved based on the configuration.");
    }
}

4. Run the Application
// Program.cs
public static void Main(string[] args)
{
    var builder = WebApplication.CreateBuilder(args);

    // Configure services and app...

    var app = builder.Build();

    // Run the app...
}

With their more sophisticated and adaptable approach to dependency injection, keyed services are a great addition to the.NET 8 DI architecture. You can gain more authority and clarity over the design of your program by comprehending their advantages, usage trends, and sophisticated applications. Learn about, play with, and take use of keyed services to create more flexible, dynamic, and organized.NET applications!

Use Devexpress Charts to give your.NET MAUI projects a boost! This blog post will walk you through the process of utilizing the free lifetime plugin Dev Express to implement the chart in.NET MAUI projects. With so many customization options, this plugin will jump straight to the implementation section.

Establishing the Project
To create a new project, launch Visual Studio 2022 and select Create a new project from the Start box.

Click the Next button after choosing the.NET MAUI App template and MAUI from the All project types drop-down menu in the Create a new project box.

Click the Next button after giving your project a name and selecting an appropriate location in the Configure your new project window.

Click the Create button located in the Additional Information window.

Once the project is created, we can able to see the Android, iOS, Windows, and other running options in the toolbar. Press the emulator or run button to build and run the app.

Install Plugin

• Library Requirement: The Dev Express's Nuget link should be mapped as a package source and we need to install "DevExpress.Maui.Charts" into our project.
• Installation via NuGet: Obtain the Charts library by searching for "DevExpress.Maui.Charts" in the NuGet Package Manager.
• User Interface Guidance: Open the NuGet Package Manager interface to facilitate the installation process.
• Visual Confirmation: The library, once searched, should appear as "DevExpress.Maui.Charts" in the NuGet interface.

Implementation
First, we need to open "MauiProgram.cs" and include the following namespace and line to allow the app to use the Chart Library.

using DevExpress.Maui;

.UseDevExpress()

Open the MainPage.xaml file and add the following namespace. (the page will be replaced according to you).
xmlns:dxc="clr-namespace:DevExpress.Maui.Charts;assembly=DevExpress.Maui.Charts"

Then, remove the default content and add an instance of the ChartView class to the page.

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:dxc="clr-namespace:DevExpress.Maui.Charts;assembly=DevExpress.Maui.Charts"
             x:Class="ScatterChartGetStarted.MainPage">
    <dxc:ChartView/>
</ContentPage>

Consider removing the event handlers from the code behind the default content. It is advisable to eliminate default styles (such as fonts, colors, and other settings) in the App.xaml file as well.

In this instance, the chart features a line series displaying the annual GDP for three countries. Generate a ViewModel.cs file that includes the following classes.
public class ViewModel {
    public CountryGdp GdpValueForUSA { get; }
    public CountryGdp GdpValueForChina { get; }
    public CountryGdp GdpValueForJapan { get; }

    public ViewModel() {
        GdpValueForUSA = new CountryGdp(
            "USA",
            new GdpValue(new DateTime(2020, 1, 1), 20.93),
            new GdpValue(new DateTime(2019, 1, 1), 21.43),
            new GdpValue(new DateTime(2018, 1, 1), 20.58),
            new GdpValue(new DateTime(2017, 1, 1), 19.391),
            new GdpValue(new DateTime(2016, 1, 1), 18.624),
            new GdpValue(new DateTime(2015, 1, 1), 18.121),
            new GdpValue(new DateTime(2014, 1, 1), 17.428),
            new GdpValue(new DateTime(2013, 1, 1), 16.692),
            new GdpValue(new DateTime(2012, 1, 1), 16.155),
            new GdpValue(new DateTime(2011, 1, 1), 15.518),
            new GdpValue(new DateTime(2010, 1, 1), 14.964)
        );
        GdpValueForChina = new CountryGdp(
            "China",
            new GdpValue(new DateTime(2020, 1, 1), 14.72),
            new GdpValue(new DateTime(2019, 1, 1), 14.34),
            new GdpValue(new DateTime(2018, 1, 1), 13.89),
            new GdpValue(new DateTime(2017, 1, 1), 12.238),
            new GdpValue(new DateTime(2016, 1, 1), 11.191),
            new GdpValue(new DateTime(2015, 1, 1), 11.065),
            new GdpValue(new DateTime(2014, 1, 1), 10.482),
            new GdpValue(new DateTime(2013, 1, 1), 9.607),
            new GdpValue(new DateTime(2012, 1, 1), 8.561),
            new GdpValue(new DateTime(2011, 1, 1), 7.573),
            new GdpValue(new DateTime(2010, 1, 1), 6.101)
        );
        GdpValueForJapan = new CountryGdp(
            "Japan",
            new GdpValue(new DateTime(2020, 1, 1), 4.888),
            new GdpValue(new DateTime(2019, 1, 1), 5.082),
            new GdpValue(new DateTime(2018, 1, 1), 4.955),
            new GdpValue(new DateTime(2017, 1, 1), 4.872),
            new GdpValue(new DateTime(2016, 1, 1), 4.949),
            new GdpValue(new DateTime(2015, 1, 1), 4.395),
            new GdpValue(new DateTime(2014, 1, 1), 4.850),
            new GdpValue(new DateTime(2013, 1, 1), 5.156),
            new GdpValue(new DateTime(2012, 1, 1), 6.203),
            new GdpValue(new DateTime(2011, 1, 1), 6.156),
            new GdpValue(new DateTime(2010, 1, 1), 5.700)
        );
    }
}

public class CountryGdp {
    public string CountryName { get; }
    public IList<GdpValue> Values { get; }

    public CountryGdp(string country, params GdpValue[] values) {
        this.CountryName = country;
        this.Values = new List<GdpValue>(values);
    }
}

public class GdpValue {
    public DateTime Year { get; }
    public double Value { get; }

    public GdpValue(DateTime year, double value) {
        this.Year = year;
        this.Value = value;
    }
}

In the MainPage.xaml file, incorporate three LineSeries objects into the ChartView.Series collection. To establish a connection between the series and data, assign each LineSeries object's Data property to a SeriesDataAdapter object. Utilize the adapter's properties to indicate the data source and fields containing arguments and values for each series.

Additionally, define a local XAML namespace referring to a CLR namespace encompassing the view model. Subsequently, employ the page's BindingContext property to link the view model with the view.
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:dxc="clr-namespace:DevExpress.Maui.Charts;assembly=DevExpress.Maui.Charts"
             xmlns:ios="clr-namespace:Microsoft.Maui.Controls.PlatformConfiguration.iOSSpecific;assembly=Microsoft.Maui.Controls"
             ios:Page.UseSafeArea="True"
             xmlns:local="clr-namespace:MauiDevExpress"
             x:Class="MauiDevExpress.MainPage">
    <ContentPage.BindingContext>
        <local:ViewModel/>
    </ContentPage.BindingContext>
    <dxc:ChartView>
        <dxc:ChartView.Series>
            <dxc:LineSeries DisplayName="{Binding GdpValueForUSA.CountryName}">
                <dxc:LineSeries.Data>
                    <dxc:SeriesDataAdapter DataSource="{Binding GdpValueForUSA.Values}"
                                           ArgumentDataMember="Year">
                        <dxc:ValueDataMember Type="Value" Member="Value"/>
                    </dxc:SeriesDataAdapter>
                </dxc:LineSeries.Data>
            </dxc:LineSeries>

            <dxc:LineSeries DisplayName="{Binding GdpValueForChina.CountryName}">
                <dxc:LineSeries.Data>
                    <dxc:SeriesDataAdapter DataSource="{Binding GdpValueForChina.Values}"
                                           ArgumentDataMember="Year">
                        <dxc:ValueDataMember Type="Value" Member="Value"/>
                    </dxc:SeriesDataAdapter>
                </dxc:LineSeries.Data>
            </dxc:LineSeries>

            <dxc:LineSeries DisplayName="{Binding GdpValueForJapan.CountryName}">
                <dxc:LineSeries.Data>
                    <dxc:SeriesDataAdapter DataSource="{Binding GdpValueForJapan.Values}"
                                           ArgumentDataMember="Year">
                        <dxc:ValueDataMember Type="Value" Member="Value"/>
                    </dxc:SeriesDataAdapter>
                </dxc:LineSeries.Data>
            </dxc:LineSeries>
        </dxc:ChartView.Series>
    </dxc:ChartView>
</ContentPage>

Configure the X-axis to display labels for years by assigning a DateTimeAxisX object with the specified settings to the ChartView.AxisX property.
<dxc:ChartView> <dxc:ChartView.AxisX>
    <dxc:DateTimeAxisX MeasureUnit="Year" GridAlignment="Year"
    GridSpacing="2"/> </dxc:ChartView.AxisX> </dxc:ChartView>

Configure the title and labels on the Y-axis. Set the ChartView.AxisY property to a NumericAxisY object and specify this object’s Title and Label properties.
<dxc:ChartView>
<!-- The X-axis config is here. -->
    <dxc:ChartView.AxisY>
        <dxc:NumericAxisY>
            <dxc:NumericAxisY.Title>
                <dxc:AxisTitle Text="Trillions of US$">
                    <dxc:AxisTitle.Style>
                        <dxc:TitleStyle>
                            <dxc:TitleStyle.TextStyle>
                                <dxc:TextStyle Size="16"/>
                            </dxc:TitleStyle.TextStyle>
                        </dxc:TitleStyle>
                    </dxc:AxisTitle.Style>
                </dxc:AxisTitle>
            </dxc:NumericAxisY.Title>
            <dxc:NumericAxisY.Label>
                <dxc:AxisLabel TextFormat="#.#" Position="Inside"/>
            </dxc:NumericAxisY.Label>
        </dxc:NumericAxisY>
    </dxc:ChartView.AxisY>
</dxc:ChartView>

Configure the legend position and orientation. Set the ChartView.Legend property to a Legend object, and specify this object’s properties as follows.
<dxc:ChartView>
    <dxc:ChartView.Legend>
        <dxc:Legend VerticalPosition="TopOutside"
                    HorizontalPosition="Center"
                    Orientation="LeftToRight"/>
    </dxc:ChartView.Legend>
</dxc:ChartView>

Establish the chart to showcase a series point hint as a crosshair cursor by setting the ChartView.Hint property to a Hint object and assigning a CrosshairHintBehavior object to Hint.Behavior. Subsequently, define the hint's content, data format, and visibility options. Set the LineSeries.HintOptions property to a SeriesCrosshairOptions object with the specified settings.
<ContentPage.Resources>
    <dxc:SeriesCrosshairOptions x:Key="lineSeriesHintOptions"
                                PointTextPattern="{}{S}: {V}M"
                                ShowInLabel="True"
                                AxisLabelVisible="True"
                                AxisLineVisible="True"/>
</ContentPage.Resources>
<dxc:ChartView>
    <dxc:ChartView.Hint>
        <dxc:Hint>
            <dxc:Hint.Behavior>
                <dxc:CrosshairHintBehavior GroupHeaderTextPattern="{}{A$YYYY}"
                                           MaxSeriesCount="3"/>
            </dxc:Hint.Behavior>
        </dxc:Hint>
    </dxc:ChartView.Hint>

    <dxc:ChartView.Series>
        <dxc:LineSeries HintOptions="{StaticResource lineSeriesHintOptions}">
            <!--Series Data-->
        </dxc:LineSeries>
        <dxc:LineSeries HintOptions="{StaticResource lineSeriesHintOptions}">
            <!--Series Data-->
        </dxc:LineSeries>
        <dxc:LineSeries HintOptions="{StaticResource lineSeriesHintOptions}">
            <!--Series Data-->
        </dxc:LineSeries>
    </dxc:ChartView.Series>
</dxc:ChartView>

Set the LineSeries.MarkersVisible property to True to display point markers. To change the line series appearance, set the LineSeries.Style property to a LineSeriesStyle object. This object’s Stroke, StrokeThickness, MarkerSize, and MarkerStyle properties allow you to configure the appearance of the series line and point markers.
<dxc:LineSeries MarkersVisible="True">
    <!--Series Data-->
    <dxc:LineSeries.Style>
        <dxc:LineSeriesStyle Stroke="#7145a7" StrokeThickness="2" MarkerSize="8">
            <dxc:LineSeriesStyle.MarkerStyle>
                <dxc:MarkerStyle Fill="#7145a7"/>
            </dxc:LineSeriesStyle.MarkerStyle>
        </dxc:LineSeriesStyle>
    </dxc:LineSeries.Style>
</dxc:LineSeries>

The following describes how to incorporate health checks into a.NET Core application:

1. Set up the NuGet package for Health Checks
You must install Microsoft.Extensions.Diagnostics in your project.The NuGet package HealthChecks. You can accomplish this by include the package reference in your project file or by using the Package Manager Console:
dotnet add package Microsoft.Extensions.Diagnostics.HealthChecks

2. Configure Health Checks
In your Startup.cs file, configure the health checks in the ConfigureServices method:
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Diagnostics.HealthChecks;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddHealthChecks();
        // Add other services...
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapHealthChecks("/health");
            // Map other endpoints...
        });
    }
}

A health check endpoint at /health is configured in this example.

3. Explain Health Examinations
By including checks for other components, you can define health checks. You may wish to verify the state of an external API, a database connection, or any other crucial element. These checks can be included in the ConfigureServices method:
public void ConfigureServices(IServiceCollection services)
{
    services.AddHealthChecks()
        .AddSqlServer("YourConnectionString", name: "DatabaseHealthCheck")
        .AddUrlGroup(new Uri("https://api.example.com"), name: "ApiHealthCheck");
    // Add other services...
}

4. Execute and Verify
Launch your application at this point, and go to the health check endpoint (http://localhost:5000/health, for example). A JSON response with the status of each health check ought to appear.

In summary

• The status of each check and any further information you supply are usually included in health check responses.
• Health checks can be modified and expanded to meet your unique needs.

It's a good idea to include health checks if you want to make sure that your.NET Core application is reliable, particularly in production scenarios where you want to keep an eye on any problems and take proactive measures to address them.

The differences between.NET 7 and.NET 8 can be better understood by contrasting their compatibility, integration powers, performance, and diagnostic features. A thorough grasp of these frameworks can also be attained by exploring the new features added in.NET 8 and comparing them with those of.NET 7. Examining these specifics can help identify the best version of the Microsoft.NET framework.

The improvements in.NET 8 constitute a noteworthy achievement for Microsoft, offering an extensive feature set with the goals of strengthening security, enhancing performance, enabling smooth integration, and streamlining maintenance. The question of whether the new features in.NET 8 are superior to those in.NET 7 is still up for dispute.

Examining the main distinctions between.NET 7 and.NET 8 is essential to obtain understanding and make wise choices about a possible upgrade. With the clarity this article will offer, it will be possible to comprehend the advantages and improvements brought forth by.NET 8.

Despite being created by Microsoft,.NET 8 and.NET 7 differ significantly. We've divided up their differences into categories based on a number of important factors, such as integration capabilities, cross-platform compatibility, performance, diagnostics, observability, and support services. It will enable you to fully comprehend how the two differ from one another.

1. Enhancements in Performance
Performance is one of the most important factors that developers consider when assessing technology for building applications. Notably,.NET 8 exhibits better optimization than.NET 7 in terms of speed and efficiency. A JIT (Just-In-Time) compiler is used by the Microsoft.NET framework in both versions, but in.NET 8, substantial improvements have been made to speed up code processing, leading to faster process execution and shorter loading times.

Furthermore, significant improvements to the runtime environment and garbage collector in.NET 8 also add to increased efficiency. With these improvements, companies can save a great deal of resources and maintain high performance even during busy hours.

2. Development Across Platforms
When it comes to facilitating the development of cross-platform compatible applications,.NET 8 outperforms.NET 7. .NET 8 is notably more capable than.NET 7 of facilitating the creation of programs customized for different hardware intrinsics.

• AVX-512
• Vector 512
• Optimized support for ARM64 and WebAssembly

These enhancements expand the accessibility of your program, making it available to a larger range of users on desktop and mobile devices, covering a variety of operating systems such as Windows, Linux, macOS, and other platforms.

3. Assistance for Platforms
For every.NET version, Microsoft offers different support durations based on two main policies: LTS (Long Term Support) and STS (Short Term Support). Long Term Support (LTS) for the.NET 8 version ensures Microsoft's assistance from November 14, 2023, to November 10, 2026. On the other hand, May 14th, 2024 is when support for the Dotnet 7 version is supposed to end. Selecting.NET 8 guarantees improved upkeep and durability for the well-being of your program.

4. Consolidation
In contrast to.NET 7, which necessitates that developers create unique code in order to integrate with APIs and other components,.NET 8 provides more convenience. Major integrated development environments, APIs, and services are all pre-supported by default. Additionally, the debugging features have been much enhanced, enabling better process execution and problem correction with less time commitment.

New Features in.NET 8
Now that we know why.NET 8 is better than.NET 7, it's imperative that you be familiar with all of its key characteristics. Comprehending these fundamental features of.NET 8 is essential as it confirms its place as a reliable technology for application development, outperforming.NET 7.

1. An improved source generator
When it comes to earlier iterations, the source generator included in.NET 8 is a major improvement. Microsoft has made significant improvements to System.Text.Json, bringing it closer to parity with the reflection-based serializer. Among the improvements included in.NET 8 are:

• Support for the "init" and "required" properties when using the source generator to serialize types.
• source-generated code formatted more neatly and systematically.
• Two new diagnoses, SYSLIB1034 and SYSLIB1039, have been added.
• Support for JsonStringEnumConverter<TEnum> is integrated into.NET 8.

2. Original AOT
By compiling only the essential parts rather than the complete codebase,.NET 8 apps improve code use with native AOT (Ahead-of-Time) compilation.

For instance, just the code specifically responsible for the login feature will be used when a user enters in with a.NET 8 application; the rest of the codebase stays in its current configuration. Thus, there are several benefits to this strategy.

• Elimination of the need for a Just-In-Time compiler.
• It increased the loading speed.
• Conservation of network and memory resources.
• Reduced execution time and resource costs.
• Improved user experience and satisfaction.

3. Enhanced Artificial Intelligence Skills
AI integration is now more stable, quick, and smooth with.NET 8. The AI components in.NET 8 are the outcome of multiple technologies working together, including Qdrant, Microsoft Teams, Azure OpenAI, Milvus, and Azure Cognitive Search. Together, these many technological advances enable.NET 8 applications to leverage sophisticated artificial intelligence (AI) capabilities, producing outputs that are accurate and exact.
  
4. Elevated .NET MAUI
.NET 8 brings significant enhancements to .NET MAUI. Now, a single codebase caters to API 34 and XCode 15, enabling seamless operation of your .NET MAUI application across WinUI, iOS, Android, and Mac Catalyst systems.

5. SHA-3 Hashing Primitives
Compared to .NET 7, the security enhancements in .NET 8 are notably robust. It introduces support for configuring the SHA-3 hashing algorithm, ensuring compatibility with APIs that complement SHA-3 within your .NET 8 applications. The SHA-3 cryptography algorithms available in .NET 8 include.

• SHA3_256, SHA3_384, and SHA3_512 (for Hashing purposes)
• HMACSHA3_256, HMACSHA3_384, and HMACSHA3_512 (for HMAC usage)
• HashAlgorithmName.SHA3_256, HashAlgorithmName.SHA3_384, and HashAlgorithmName.SHA3_512 (for developer-configurable algorithm settings)
• RSAEncryptionPadding.OaepSHA3_256, RSAEncryptionPadding.OaepSHA3_384, and RSAEncryptionPadding.OaepSHA3_512 (for RSA OAEP encryption)

6. HTTPS Proxy

Support: Man-in-the-middle attacks are prevented with HTTPS proxy support, which.NET 8 brings to improve the security of client connections. By creating encrypted communication channels, this function protects the confidentiality and integrity of data.

Should you upgrade from .NET 7 to .NET 8?
Considering the analysis of various factors, .NET 8 is more advanced and proficient than .NET 7. So, you should upgrade your application to .NET 8.

Conclusion
.NET 8 stands out as a remarkable software development technology by Microsoft, surpassing .NET 7 in every aspect. From performance and integration to C# code compilation, observability, and support, .NET 8 excels in every aspect when compared. Moreover, .NET experts and professionals widely endorse .NET 8 for their projects.

In web development, response compression is an essential technique used to maximize the speed and responsiveness of HTTP applications. Response compression improves user experience, speeds up page loads, and uses less bandwidth by lowering the size of HTTP responses.

Advantages of Compression Response:

• Enhanced Performance: Compression speeds up page loads by reducing the quantity of data sent over the network.
• Decreased Bandwidth Usage: Less data transfer from compressed answers results in lower hosting and bandwidth expenses.
• Improved SEO: Page load times are taken into account by search engines, which could result in a website that loads faster ranking better in search results.

Response Compression Implementation in.NET
Middleware can be used to implement response compression in a.NET web application. This is an example that makes use of AddResponseCompression, a.NET middleware.
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
});

var app = builder.Build();
app.UseResponseCompression();
app.MapGet("/", () => "Hello World!");
app.Run();

In this example, EnableForHttps is set to true, but caution is advised due to potential security vulnerabilities like CRIME and BREACH attacks. It's recommended to use anti-forgery tokens to mitigate these risks.

builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
    options.Providers.Add<BrotliCompressProvider>();
    options.Providers.Add<GzipCompressProvider>();
    options.MimeTypes = ResponseCompressionDefaults.MimeTypes;
});

Compression Levels
Each compression provider has different compression levels.

builder.Services.Configure<BrotliCompressionProviderOptions>(options =>
{
    options.Level = CompressionLevel.SmallestSize;
});
builder.Services.Configure<GzipCompressProviderOptions>(options =>
{
    options.Level = CompressionLevel.Optimal;
});

These levels include Optimal, Fastest, No Compression, and Smallest Size.

Custom Providers
You can also create custom compression providers by implementing the ICompressionProvider interface.
builder.Services.AddResponseCompression(options =>
{
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
    options.Providers.Add<CustomCompressionProvider>();
});

When to Compress and When not?

Compress responses that are not natively compressed (e.g., CSS, JS, HTML, XML, JSON). Avoid compressing natively compressed assets (e.g., PNG) and smaller files (150-1000 bytes).

Verifying Compression
To ensure compression is working, use middleware, set compression levels, and send requests from tools like Postman with different values of Accept-Encoding in the header.

Default MIME Types Supported
Common MIME types supported by default include text/CSS, text/XML, text/JSON, text/HTML, text/plain, application/XML, application/JSON, application/WASM, and application/javascript.

One useful method for improving the performance and user experience of web applications is to add response compression. Smaller HTTP response sizes result in quicker page loads, less bandwidth used, and possibly higher search engine ranks. A strong framework for effectively handling response compression is provided by the AddResponseCompression middleware in the.NET environment, in conjunction with providers such as Brotli and Gzip compression. It is imperative to take security concerns into account, particularly when enabling HTTPS compression. It is recommended to take steps to address potential vulnerabilities such as CRIME and BREACH attacks, such as implementing anti-forgery tokens.

Developers can adapt compression algorithms to individual application requirements thanks to the flexibility of bespoke compression providers. It is possible to adjust compression levels according to optimization, speed, or file size considerations. It's important to know when to apply compression, focusing on replies that aren't already compressed and avoiding it on smaller or previously compressed data. It is important to confirm that the compression settings you have put in place are working as intended by using tools such as Postman to verify the efficiency of the compression with different Accept-Encoding header variants.

Developers can further improve the effectiveness of response compression by covering a variety of frequently used content kinds by utilizing default MIME types for compression. To put it simply, response compression is a crucial component of web development that, when used carefully, greatly improves an application's overall functionality, responsiveness, and cost-effectiveness..