Memory dumps of a developer

Connecting Azure Blob Storage account using Managed Identity

Fri, 09 Dec 2022 07:57:00 GMT

In the previous post, we saw that we can connect to Azure KeyVault from ASP.NET Core application using the default credentials. If you haven't read that, please find it here

Manage application settings with Azure KeyVault

But this is not a secure way of doing things obviously due to security concerns. In order to overcome this, the recommended approach is used to Managed Identity in Azure. This will work only if your application is hosted in Azure. It is similar to a service principal which connects on your app's behalf to communicate with other resources

Create Managed Identity

The first step is to create a Managed Identity resource in Azure and then give read permission for this identity in the Keyvault which you need to communicate

You can refer to the official documentation given below to perform this step

Managed identities for Azure resources

Connecting to KeyVault from ASP.NET Core Web App

In my sample code, I want to connect to a storage account using MI, I have added the necessary configuration entries is my appsettings.json. This can change depending our your requirement

"AzureStorage": {
    "AccountName": "gab22demostorage",
    "ContainerName": "file-container"
    
  },
"AzureKeyVault": {
    "keyvault-url": "https://gab22demo-rg.vault.azure.net/",
    "mi-client-id": "your mi id here"
  },

Now, in my method where I want to connect to the storage account, add the below code


var accountName = _configuration["AzureStorage:AccountName"];
var containerName = _configuration["AzureStorage:ContainerName"];
var miClientId = _configuration["AzureKeyVault:mi-client-id"];

// Construct the blob container endpoint from the arguments.
string containerEndpoint = $"https://{accountName}.blob.core.windows.net/{containerName}";

// Get a credential and create a client object for the blob container.
BlobContainerClient blobContainer = new BlobContainerClient(new Uri(containerEndpoint),
	new ManagedIdentityCredential(miClientId));

foreach (var itm in products)
{
	BlobClient blobClient = blobContainer.GetBlobClient($"uploads/{itm.ImageFileName}");
        using (var memoryStream = new MemoryStream())
        {
        	await blobClient.DownloadToAsync(memoryStream);
                var bytes = memoryStream.ToArray();
                var b64String = Convert.ToBase64String(bytes);
                itm.ImageUri = "data:image/png;base64," + b64String;
	}
}

What we are doing basically here is

reading the configuration from appsettings.json file
connecting to the storage account using MI
iterates through the blob container to download the image file

Securing Azure KeyVault connections using Managed Identity

Sat, 26 Nov 2022 11:54:00 GMT

In the previous post we saw that we can connect to Azure KeyVault from ASP.NET Core application using the default credentials. If you haven't read that, please find it here

Manage application settings with Azure KeyVault

Create Managed Identity

The first step is to create a Managed Identity resource in Azure and then give read permission for this identity in the Keyvault which you need to communicate

You can refer to the official documentation given below to perform this step

Managed identities for Azure resources

Connecting to KeyVault from ASP.NET Core Web App

Add a Nuget package called Azure.Identity

<PackageReference Include="Azure.Identity" Version="1.6.0" />

Modify the entries in your appsettings.json to add entries for the key vault URL and managed identity id

 "AzureKeyVault": {
    "keyvault-url": "https://gab22demo-rg.vault.azure.net/",
    "mi-client-id": "72b0cc31-b3f9-4230-9e12-bd3f5c793e55"
  },

Now, in the startup code, add the following snippet

var keyVaultURL = hostingContext.Configuration.GetSection("AzureKeyVault:keyvault-url").Value;
var miClientId = hostingContext.Configuration.GetSection("AzureKeyVault:mi-client-id").Value;

var client = new SecretClient(new Uri(keyVaultURL), new ManagedIdentityCredential(miClientId)); 
config.AddAzureKeyVault(client: client, new KeyVaultSecretManager());

What we are doing basically here is

adds the KeyVault as a configuration provider
sets up the connection to key vault using AddAzureKeyVault method

Once you complete this step, you will be able to access the key vault references in the same way you access values from other configuration providers such as appsetting.json

A sample snippet is given below. Here we are using the IConfiguration instance to read the value DBConnection which is being fetched from the vault during the startup phase.

private readonly ILogger<HomeController> _logger;
private readonly IConfiguration _configuration; 

public HomeController(ILogger<HomeController> logger, IConfiguration configuration)
{
    _logger = logger;
    _configuration = configuration;
}

public IActionResult Index()
{
    List<Product> products = new();
    using (var db = new GABDemoDbContext(_configuration["DBConnection"]))
    {
        products = db.Product.OrderBy(x => x.Name).ToList();
    }
    return View(products);
}

Manage application settings with Azure KeyVault

Wed, 09 Nov 2022 11:54:00 GMT

Securing your data and application configuration should be of prime importance for an application developer/architect and needs to be taken care of during the design phase itself. It is always better to take preventive steps rather than do firefighting after an incident. There are a lot of best practices out there to safeguard the data, but from time to time we ignore/forget to securely store app configuration settings.

Very often developers tend to store hard-coded passwords, tokens, authorization keys, etc in the code or in the application configuration files and then commit the code into the version control. If your repo is publically available or some bad actors got access to it, then you may end up in a lot of trouble. There are automated bots that look for this kind of information by scanning the repos publically available in GitHub or BitBucket and then target your infrastructure with these credentials

Securing the configuration settings

There are a lot of ways you can make that secure, for example by encrypting the entries in the configuration files or by keeping that sensitive information in some other medium such as a database. Another option is to rely on resources provided by cloud vendors such as Microsoft or Amazon.

Azure KeyVault is one such cloud service provided by Microsoft for securely storing and accessing not only secrets but also certificates, keys, passwords, etc. Please refer to this official document for more details about Azure KeyVault. Apart from storing it securely, KeyVault provides additional features such as access control, audit logging, versioning, validity, and much more. With the help of these features, we can make sure that only authorized personnel/app has access to the data with proper auditing and expiration controls.

Creating a KeyVault in Azure

We can create a resource in Azure in a number of ways, here I am going to show you how to create a vault from the portal as well as with commands using Azure CLI.

Portal

Just type Key Vault in the search bar at the top and select Key Vaults from the results. From the next page, select the Create option and you will get a window like the one below. There, just select the Resource Group, specify a name for the key vault, region, and pricing tier, and leave the rest with the default values

Azure CLI

az keyvault create --name "gab22demo-rg" --resource-group "GAB22RG" --location "SouthIndia"

Creating a secret

Before you can add a secret in the key vault, you will need to give yourself access to either add or manage it. In order to do that, you can go to Access Policies from the left menu under your key vault and then select Add Access Policy. Since we are dealing only with secrets, we will only select the necessary permissions needed for the same and then the identity to give access to

CLI Command

az keyvault secret set --vault-name "gab22demo-rg" --name "DBConnection" --value "<your connection string>"

Reading secrets in your code

So we have created the key vault and added a secret in the vault to store the database connection string. Now, let's read this connection string from the vault and establish a connection to the database from the code base. For this post, I am going to use a .NET6 Web application for the demo purpose.

In Azure, while creating the key vault it exposes API endpoint which can be used in our code to establish a connection to the vault for performing various operations. To get started, we will need to install a nuget package named Microsoft.Extensions.Configuration.AzureKeyVault

We are going to store the key vault endpoint in the config file and will load it into the configuration collection during the bootstrapping phase

So, let's add an entry in the appsettings.json file as shown below

  "AzureKeyVault": {
    "keyvault-url": "https://gab22demo-rg.vault.azure.net/"
  },

Now, in the startup code, add the following snippet


builder.Host
    .ConfigureAppConfiguration((hostingContext, config) =>
    {
        AzureServiceTokenProvider azureServiceTokenProvider = new();
        KeyVaultClient keyVaultClient = new(
            new KeyVaultClient.AuthenticationCallback(
                azureServiceTokenProvider.KeyVaultTokenCallback
                ));
        config.AddAzureKeyVault(hostingContext.Configuration.GetSection("AzureKeyVault:keyvault-url").Value,
            keyVaultClient,
            new DefaultKeyVaultSecretManager());

    });

What we are doing basically here is

adds the KeyVault as a configuration provider
sets up the connection to the key vault using AddAzureKeyVault method

Once you complete this step, you will be able to access the key vault references in the same way you access values from other configuration providers such as appsetting.json

A sample snippet is given below. Here we are using the IConfiguration instance to read the value DBConnection which is being fetched from the vault during the startup phase.

private readonly ILogger<HomeController> _logger;
private readonly IConfiguration _configuration; 

public HomeController(ILogger<HomeController> logger, IConfiguration configuration)
{
    _logger = logger;
    _configuration = configuration;
}

public IActionResult Index()
{
    List<Product> products = new();
    using (var db = new GABDemoDbContext(_configuration["DBConnection"]))
    {
        products = db.Product.OrderBy(x => x.Name).ToList();
    }
    return View(products);
}

Adding Serilog to Azure Functions created using .NET 5

Sat, 03 Apr 2021 16:26:00 GMT

The post is based on .NET 5.0

Before the release of .NET 5, all functions developed using .NET ran as a class library in Azure and it was running inside the same process as the host. But with .NET 5, a function app built with .NET 5 runs in an isolated worker process which lets you decouple your function code from the runtime. A .NET isolated function is basically a console application targeting .NET 5 and requires the following files

host.json file
local.settings.json file
C# project file which defines the project and dependencies
Program.cs file(entry point of the app)

In this post, I will go through the steps that are needed for creating a .NET 5 Azure function, integrating Serilog for file logging, debugging, and running it locally, and then move on to publishing the function to Azure. You may already know that Azure functions already support some form of logging out of the box, but you may need to implement custom logging mechanisms depending on your need or for satisfying organizational requirements. I am going to use Serilog, which is a third-party logging provider which supports .NET and is also one of the most widely used in the ecosystem

Pre-requisites

There are some things you need before you start implementing this one. Azure Subscription is needed for hosting the functions in Azure, .NET 5 SDK, and Azure Functions Core Tools. Azure CLI is needed for developing, debugging, and publishing the app to Azure and VS Code for writing code.

Azure Subscription

.NET 5 SDK

Azure Function Core Tools version 3.0.3381 or greater

Visual Studio Code

Azure CLI

Step 1

The first step is to create a new Functions project, we will be using the func command to create a new one from the command line. Even though you can edit and debug the project in Visual Studio, full support is not yet available as the project templates for creating the project and all. The following command will create a new Azure Function project and specifying the runtime as dotnetisolated enables you to run the app on .NET 5

func init FunctionLogger --worker-runtime dotnetisolated

When this command is executed, it will create all the necessary files including the host.json and local.settings.json files. The host.json file contains the configuration options affecting all the functions in your app whereas the other file can be used for storing options such as connection strings, secrets, and other settings used by your app. Since this file can have sensitive data, it is excluded when you check in the code to source control

Step 2

Next, we will move on to create a new function in the project which is triggered by an HTTP request. The below statement creates a function named HttpExample using the HttpTrigger template and enables anonymous authentication

func new --name HttpExample --template "HTTP trigger" --authlevel "anonymous"

public  class HttpExample
    {
        [Function("HttpExample")]
        public  HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
            FunctionContext executionContext)
        {
            var logger = executionContext.GetLogger("HttpExample");
            logger.LogInformation("C# HTTP trigger function processed a request.");

            var response = req.CreateResponse(HttpStatusCode.OK);
            response.Headers.Add("Content-Type", "text/plain; charset=utf-8");

            response.WriteString("Welcome to Azure Functions!");

            return response;
        }
    }

We are not going to modifying the contents of the function created by default, because these statements are sufficient for demonstrating the logging mechanism

Step 3

To use Serilog, you will need to add some packages in order to use it in your application. The package named Serilog is having the core functionality and Serilog.File and Serilog.Console is having the logic for writing it to the console and file respectively. In Serilog, these are called Sinks and there are a lot of them available for writing logs to Database, Seq, App Insights etc

dotnet add package Microsoft.Azure.Functions.Extensions
dotnet add package Serilog
dotnet add package Serilog.Extensions.Logging
dotnet add package Serilog.Sinks.Console
dotnet add package Serilog.Sinks.File

Step 4

In a .NET 5 isolated function, you can configure the startup option by modify the main method in the Program.cs file. The entry point of your function is this method and here you will be able to configure the host options. To integrate Serilog, you will need to import them into your project first and then configure the pipeline as shown below. Here I'm enabling both the file and console sinks, and the file sink is configured as a rolling file which creates a new file for each day.

    public class Program
    {
        public static void Main()
        {
            var host = new HostBuilder()
                .ConfigureFunctionsWorkerDefaults()
                // .ConfigureAppConfiguration((hostingcontext,config)=>{

                // })
                .ConfigureServices(s=>
                {
                     var logger = new LoggerConfiguration()
                    .WriteTo.Console()
                    .WriteTo.File("log.txt", rollingInterval: RollingInterval.Day)
                    .CreateLogger();
                    s.AddLogging(lb => lb.AddSerilog(logger));
                })
                .Build();

            host.Run();
        }
    }

Step 5

Let's compile the project and run the app by going to the terminal and executing the below command. It will run the function locally using Azure Function core tools

func start --dotnet-isolated

When the HTTP trigger function is executed by invoking the request from the browser, you can see that information is now being written to the console as well as the log file. The file will be created by the Serilog provider if it is not there and will be rolled over at the end of each day

Step 6

Now, let's publish the function app to Azure. As of now, functions developed using .NET 5 can be published only using the Azure CLI and are not supported in Portal as well as Visual Studio.

First, I am going to create a resource group and a storage account in Azure which are the pre-requisites for creating a function app in Azure

You can either use the portal or Azure CLI for the same

Now, we will proceed to create the function app from the CLI using the below command. It will create the function in the resource group created previously and will use a consumption plan. It will use the storage account which we created earlier for the function management and uses .NET 5 and function V3 runtime for executing the function

az functionapp create --resource-group function-demo-rg --consumption-plan-location eastus --runtime dotnet-isolated --runtime-version 5.0 --functions-version 3 --name FunctionLoggerApp --storage-account functiondemostorage

Note: Make sure that you have the latest version of the Azure CLI, otherwise you get errors saying "dotnet-isolated is not a valid value for --runtime"

We will need to make a slight adjustment in our code to specify the location of the log file path. When I tried to put the log file in the folder from where our application was running, the logs were not getting written into it. By default, Azure creates a log folder outside the root folder of your app to write all the telemetry generated by the runtime. So when I used that path, it started writing information into it. Now my Program.cs code looks like the one below

     var host = new HostBuilder()
                .ConfigureFunctionsWorkerDefaults()
                // .ConfigureAppConfiguration((hostingcontext,config)=>{

                // })
                .ConfigureServices(s=>
                {
                    //If the app is hosted in Azure, then the env variable WEBSITE_SITE_NAME will have a value
                    var filepath = !string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME"))?@"D:\home\LogFiles\Application\log.txt":"log.txt";
    
                     var logger = new LoggerConfiguration()
                    .WriteTo.Console()
                    .WriteTo.File(filepath, rollingInterval: RollingInterval.Day)
                    .CreateLogger();
                    s.AddLogging(lb => lb.AddSerilog(logger));
                })
                .Build();

            host.Run();

To publish the app to Azure

func azure functionapp publish FunctionLoggerApp

If you browse to the endpoint of your function app using a browser, you will see the same message we got while testing in local, and our log file in the cloud will now have info written into it

Learn how to split log data into different tables using Serilog in ASP.NET Core

Thu, 23 Apr 2020 08:31:00 GMT

For most of the application developers, file systems are the primary choice for storing the information generated by the logging providers. One of the main drawbacks of using the files is that it's very difficult for the search for information or to do an analysis of the information written to it over time. Third-party logging providers such as Serilog have facilities to persist the data in database tables instead of the file system. Even then, if you use a single table to write all you errors and other debug information, the size of the table will grow considerably over time which can affect the performance of the whole operation itself.

So, in this post, I will explore the possibility of using multiple tables for storing the logging information using Serilog. If you are new to Serilog, please refer to my previous articles on the same here using the links given below.

Code snippets in this post are based on .NET Core 5.0 Preview 5

Step 1: Create a Web Application in .NET Core

To get started we will create a new empty web application using the default template available in Visual Studio. Goto File -> New Project -> ASP.NET Core Web Application

Give a name for the application, leave the rest of the fields with default values and click Create

In the next window, select Web Application as a project template. Before you click on the Create button, make sure that you have selected the desired version of .NET Core in the dropdown shown at the top. Here, for this one, I selected .NET 5.0

You can also do this from .NET CLI using the following command
dotnet new web  --name SerilogMultipleTables
When the command is executed it will scaffold a new application using the MVC structure and then restores the necessary packages needed for the default template.

By default, it will create two json files named, appsettings.json and appsettings.development.json. These are the configuration files for the application and is chosen based on the environment where your application is running. These files will have a default configuration as shown below basically sets the default level for logging.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  }
}

By default, it is set as Information, which writes a lot of data to the logs. This setting is very useful while we are developing the application, but we should set it higher severity levels when the application is deployed to higher environments. Since Serilog is not going to reference this section, we can safely remove this from the configuration files

Step 2: Adding Serilog

To integrate Serilog with our application, we will need to add the following packages

Serilog.AspNetCore - Base package dedicated for ASP .NET Core integration
Serilog.Settings.Configuration - Provider that reads from the Configuration object
Serilog.Filters.Expressions - Used for expression-based event filtering
Serilog.Sinks.MSSqlServer - Used for writing logs in to one or more files

In the solution explorer window, right-click on the solution and choose Manage NuGet Packages from the context menu. Search for the packages given above and click on install to add it

To add the packages into your projects using .NET CLI, execute the commands given below from the command prompt
dotnet add package Serilog.AspNetCore
dotnet add package Serilog.Settings.Configuration
dotnet add package Serilog.Filters.Expressions
dotnet add package Serilog.Filters.MSSqlServer

Step 3: Added Serilog settings in the configuration file

Now we will modify our appsettings.json file to add the settings for Serilog. In one of the earlier step, we removed the default entries for logging and will add the following instead of that

"Serilog": {
    "MinimumLevel": {
      "Default": "Debug",
      "Override": {
        "Default": "Information",
        "Microsoft": "Warning",
        "Microsoft.Hosting.Lifetime": "Information"
      }
    },
    "WriteTo": [
      {
        "Name": "Logger",
        "Args": {
          "configureLogger": {
            "Filter": [
              {
                "Name": "ByIncludingOnly",
                "Args": {
                  "expression": "(@Level = 'Error' or @Level = 'Fatal' or @Level = 'Warning')"
                }
              }
            ],
            "WriteTo": [
              {
                "Name": "MSSqlServer",
                "Args": {
                  "connectionString": "Server=(localdb)\\MSSQLLocalDB;Database=Employee;Trusted_Connection=True;MultipleActiveResultSets=true",
                  "tableName": "ErrorLogs",
                  "autoCreateSqlTable": true
                }
              }
            ]
          }
        }
      },
      {
        "Name": "Logger",
        "Args": {
          "configureLogger": {
            "Filter": [
              {
                "Name": "ByIncludingOnly",
                "Args": {
                  "expression": "(@Level = 'Information' or @Level = 'Debug')"
                }
              }
            ],
            "WriteTo": [
              {
                "Name": "MSSqlServer",
                "Args": {
                  "connectionString": "Server=(localdb)\\MSSQLLocalDB;Database=Employee;Trusted_Connection=True;MultipleActiveResultSets=true",
                  "tableName": "InformationLogs",
                  "autoCreateSqlTable": true
                }
              }
            ]
          }
        }
      }
    ],
    "Enrich": [
      "FromLogContext",
      "WithMachineName"
    ],
    "Properties": {
      "Application": "MultipleLogFilesSample"
    }
  }

Here we have configured entries for writing logs into two tables depending upon the severity. For the first one, we set up the filter like this

"configureLogger": {
    "Filter": [
        {
        "Name": "ByIncludingOnly",
        "Args": {
            "expression": "(@Level = 'Error' or @Level = 'Fatal' or @Level = 'Warning')"
        }
        }
    ],

Under the WriteTo section, we will need to configure the database connection string, name of the table that will be created for writing the logging information. I have specified different names for the table in the two-section so that it will split the writing operation between the tables depending upon the levels. Also, I have enabled the option to automatically create the tables, so when you run the application for the first time it will create the tables with the following schema.

CREATE TABLE [dbo].[ErrorLogs] (
    [Id]              INT            IDENTITY (1, 1) NOT NULL,
    [Message]         NVARCHAR (MAX) NULL,
    [MessageTemplate] NVARCHAR (MAX) NULL,
    [Level]           NVARCHAR (MAX) NULL,
    [TimeStamp]       DATETIME       NULL,
    [Exception]       NVARCHAR (MAX) NULL,
    [Properties]      NVARCHAR (MAX) NULL
);

Because of the conditions, we specified in the configuration file, only Error, Fatal and Warning types of logs will be written into a table named ErrorLogs. Similarly, for the second one, it will write into the file named InformationLogs if and only if the level is Debug or Information'

Step 4: Integrate Serilog in the application

To configure Serilog in our application, we will modify our Program.cs file to call the Serilog middleware as shown below

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>

Step 5: Writing logs from the application

Let's modify the IndexModel method in the Index.cshtml.cs file to simulate the call to logger methods which in turns writes information to the files

public IndexModel(ILogger<IndexModel> logger)
{
    _logger = logger;
    _logger.LogInformation("Writing to log file with INFORMATION severity level.");
    _logger.LogDebug("Writing to log file with DEBUG severity level."); 
    _logger.LogWarning("Writing to log file with WARNING severity level.");
    _logger.LogError("Writing to log file with ERROR severity level.");
    _logger.LogCritical("Writing to log file with CRITICAL severity level.");

}

If you run the application now, you will see the information in written into different files based on the log levels

ErrorLogs Table

InformationLogs Table

Writing logs to different files using Serilog in ASP.NET Core Web Application

Wed, 15 Apr 2020 18:16:00 GMT

Application log files play an important role in analyzing the bugs and for troubleshooting issues in an application. It’s worth noting that the log files are also used for writing information about events and other information that occurs when the application is running or serving requests in the case of a web application. Most application developers use a single file to log everything from errors, warnings, debug information, etc. There is no harm in following this approach, but the downside is that it will be harder for you to segregate information from the file easily. We can easily overcome this by maintaining multiple log files depending on the need. In this post, I am going to show how we can achieve this with Serilog

Serilog is a popular third party diagnostic logging library for .NET applications, I have already written some post about it and it’s usage already. If you are new to Serilog, please refer to those posts using the links given below.

Code snippets in this post are based on .NET Core 5.0 Preview 5

Step 1 : Create a Web Application in .NET Core

Create a new ASP.NET Core MVC application using the below command

dotnet new mvc  --name MultiLogFileSample

You can also do this from Visual Studio by going into File -> New Project -> ASP .NET Core Web Application

When the command is executed it will scaffold a new application using the MVC structure and then restores the necessary packages needed for the default template.

By default, it will create two json files named, appsettings.json and appsettings.development.json. These are the configuration files for the application and are chosen based on the environment where your application is running. These files will have a default configuration as shown below basically sets the default level for logging.

{
  "Logging":{
    "LogLevel":{
      "Default":Information",
      "Microsoft":Warning",
      "Microsoft.Hosting.Lifetime":Information"
    }
  }
}

Step 2: Adding Serilog

To integrate Serilog with our application, we will need to add the following packages

Serilog.AspNetCore - Base package dedicated for ASP .NET Core integration
Serilog.Settings.Configuration - Provider that reads from the Configuration object
Serilog.Filters.Expressions - Used for expression-based event filtering
Serilog.Sinks.File - Used for writing logs in to one or more files

To add the packages into your projects, execute the commands given below from the command prompt

dotnet add package Serilog.AspNetCore
dotnet add package Serilog.Settings.Configuration
dotnet add package Serilog.Filters.Expressions
dotnet add package Serilog.Filters.File

To do this from Visual Studio, go to Manage NuGet Packages and then add the packages from there

Step 3: Added Serilog settings in the configuration file

Now we will modify our appsettings.json file to add the settings for Serilog. In one of the earlier step, we removed the default entries for logging and will add the following instead of that

"Serilog": {
    "MinimumLevel": {
      "Default": "Debug",
      "Override": {
        "Default": "Information",
        "Microsoft": "Warning",
        "Microsoft.Hosting.Lifetime": "Information"
      }
    },
    "WriteTo": [
      {
        "Name": "Logger",
        "Args": {
          "configureLogger": {
            "Filter": [
              {
                "Name": "ByIncludingOnly",
                "Args": {
                  "expression": "(@Level = 'Error' or @Level = 'Fatal' or @Level = 'Warning')"
                }
              }
            ],
            "WriteTo": [
              {
                "Name": "File",
                "Args": {
                  "path": "Logs/ex_.log",
                  "outputTemplate": "{Timestamp:o} [{Level:u3}] ({SourceContext}) {Message}{NewLine}{Exception}",
                  "rollingInterval": "Day",
                  "retainedFileCountLimit": 7
                }
              }
            ]
          }
        }
      },
      {
        "Name": "Logger",
        "Args": {
          "configureLogger": {
            "Filter": [
              {
                "Name": "ByIncludingOnly",
                "Args": {
                  "expression": "(@Level = 'Information' or @Level = 'Debug')"
                }
              }
            ],
            "WriteTo": [
              {
                "Name": "File",
                "Args": {
                  "path": "Logs/cp_.log",
                  "outputTemplate": "{Timestamp:o} [{Level:u3}] ({SourceContext}) {Message}{NewLine}{Exception}",
                  "rollingInterval": "Day",
                  "retainedFileCountLimit": 7
                }
              }
            ]
          }
        }
      }
    ],
    "Enrich": [
      "FromLogContext",
      "WithMachineName"
    ],
    "Properties": {
      "Application": "MultipleLogFilesSample"
    }
  }

Here we have configured entries for writing logs into two files depending upon the severity. For the first one, we set up the filter like this

"configureLogger": {
    "Filter": [
        {
        "Name": "ByIncludingOnly",
        "Args": {
            "expression": "(@Level = 'Error' or @Level = 'Fatal' or @Level = 'Warning')"
        }
        }
    ],

Because of this condition, only Error, Fatal and Warning types of logs will be written into a file named ex-*.log. Since we have configured it as a rolling file, the date will also get appended to the file name. Similarly, for the second one, it will write into the file named cp-*.log if and only if the level is Debug or Information’

Step 4: Integrate Serilog in the application

To configure Serilog in our application, we will modify our Program.cs file to call the Serilog middleware as shown below

public static IHostBuilder CreateHostBuilder(string[] args)=>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        })
        .UseSerilog((hostingContext, loggerConfig) =>
            loggerConfig.ReadFrom.Configuration(hostingContext.Configuration)
        );

Step 5: Writing logs from the application

Let’s modify the Index method in the HomeController.cs file to simulate the call to logger methods which in turns writes information to the files

public HomeController(ILogger<HomeController> logger)
{
    _logger = logger;
    _logger.LogInformation(Writing to log file with INFORMATION severity level.");
    _logger.LogDebug(Writing to log file with DEBUG severity level."); 
    _logger.LogWarning(Writing to log file with WARNING severity level.");
    _logger.LogError(Writing to log file with ERROR severity level.");
    _logger.LogCritical(Writing to log file with CRITICAL severity level.");

}

If you run the application now, you will see the information in written into different files based on the log levels
cp-*.log

2020-06-20T23:11:42.0922074+05:30 [INF] (MultipleLogFilesSample.Controllers.HomeController) This is a log with INFORMATION severity level.
2020-06-20T23:11:42.0934669+05:30 [DBG] (MultipleLogFilesSample.Controllers.HomeController) This is a log with DEBUG severity level.

ex-*.log

2020-06-20T23:11:42.0934979+05:30 [WRN] (MultipleLogFilesSample.Controllers.HomeController) This is a log with WARNING severity level.
2020-06-20T23:11:42.0950269+05:30 [ERR] (MultipleLogFilesSample.Controllers.HomeController) This is a log with ERROR severity level.
2020-06-20T23:11:42.0958420+05:30 [FTL] (MultipleLogFilesSample.Controllers.HomeController) This is a log with CRITICAL severity level.

Write your logs into database in an ASP.NET Core application using Serilog

Sun, 02 Feb 2020 08:00:00 GMT

In most scenarios, we normally use a flat-files for writing your logs or exception messages. But what if you write that information into the table in a database instead of a file. To implement this functionality, we can make use of third-party providers such as Serilog to log information in a SQL server database. Even though it's not a recommended approach, one can easily search the logs by executing SQL queries against the table.

Installing Packages

Serilog provides the functionality to write logs to different sources such as files, trace logs, database and the providers for these are called Serilog Sinks. To write logs to a table in a SQL Server database, you will need to add the following NuGet packages

Install-Package Serilog
Install-Package Serilog.Settings.Configuration
Install-Package Serilog.Sinks.MSSqlServer

The first package contains the core runtime, the second package can read the key under the "Serilog" section from a valid IConfiguration source and the last one is responsible for making the connection to the database and writing information into the log table.

Configuring Serilog

Modify the appsettings.json file to add a new section called "Serilog". We will set up the connection string to the database, provide the name of the table and instruct Serilog to create the table if not found in the DB

"Serilog": {
    "MinimumLevel": "Error",
    "WriteTo": [
      {
        "Name": "MSSqlServer",
        "Args": {
          "connectionString": "Server=(localdb)\\MSSQLLocalDB;Database=Employee;Trusted_Connection=True;MultipleActiveResultSets=true",
          "tableName": "Logs",
          "autoCreateSqlTable": true
        }
      }
    ]
  },

Then modify the Program.cs file to read these values from the JSON file

var configSettings = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();

.ConfigureAppConfiguration(config =>
{
    config.AddConfiguration(configSettings);
})

Now, to hook up Serilog provider, import the namespace first

using Serilog

An add the following in the CreateHostBuilder method

Log.Logger = new LoggerConfiguration()
    .ReadFrom.Configuration(configSettings)
    .CreateLogger();

.ConfigureLogging(logging =>
{
    logging.AddSerilog();
})

Here's the full code

public static IHostBuilder CreateHostBuilder(string[] args)
{
    var configSettings = new ConfigurationBuilder()
        .AddJsonFile("appsettings.json")
        .Build();

    Log.Logger = new LoggerConfiguration()
        .ReadFrom.Configuration(configSettings)
        .CreateLogger();

    return Host.CreateDefaultBuilder(args)
    .ConfigureAppConfiguration(config =>
    {
        config.AddConfiguration(configSettings);
    })
    .ConfigureLogging(logging =>
    {
        logging.AddSerilog();
    })
    .ConfigureWebHostDefaults(webBuilder =>
    {
        webBuilder.UseStartup();
    });

}

Testing it out

Create a new MVC application from Visual Studio By default, Logging is enabled in the application via the ILogger interface. In the case of a web app, you will get an ILogger from DI container and use that object for writing into the configured log providers Let's see how we can do that in HomeController

First, create a private variable

private readonly ILogger<HomeController> _logger;

Then modify the constructor as shown below

public HomeController(ILogger logger)
{
    _logger = logger;
}

Now, use the LogError method to write a message into the log

public IActionResult Index()
{
    _logger.LogError("Writing to log");
    return View();
}

If you run the application and goto the home page, you will see this message written to the table.

Rollover log files automatically in an ASP.NET Core Web Application using Serilog

Sun, 19 Jan 2020 13:15:00 GMT

We all implement logging in whatever applications we develop and over time it will grow bigger by each passing day. If we don't control that over time we will run into problems, especially with the size. Most of the logging providers help to overcome this by using rolling log providers which automatically archives the current log file when it reaches specific criteria or a threshold and creates the new file to resume the logging. In this article we will how we can make of the rolling file provider supported by Serilog to implement this functionality.

Step 1: Install Packages

First, install the following packages

Install-Package Serilog
Install-Package Serilog.Extensions.Logging
Install-Package Serilog.Sinks.File

The first package has all the core functionalities of Serilog whereas the second one is a provider for the logging subsystem used by ASP.NET Core(Microsoft.Extensions.Logging). The third package is responsible for writing the log information to the file, manages the rollover and all the related functionalities

Step 2: Configure Serilog

Modify the appsettings.json file to include the path for the log file

 "Logging": {
    "LogPath": "logs//ex.log",
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  }

Then, configure the sink to read this path from the config file and set it up to write to the file by modifying the CreateHostBuilder method in Program.cs file

 
var configSettings = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .Build();

Log.Logger = new LoggerConfiguration()

    .WriteTo.File(configSettings["Logging:LogPath"], rollOnFileSizeLimit:true,fileSizeLimitBytes:10)
    .CreateLogger()

Here, I configured the policy to roll over the file when the size of the current log file reaches 100 Kb. And finally, add the provider while bootstrapping the host as shown below

public static IHostBuilder CreateHostBuilder(string[] args)
{
    var configSettings = new ConfigurationBuilder()
        .AddJsonFile("appsettings.json")
        .Build();

    Log.Logger = new LoggerConfiguration()

        .WriteTo.File(configSettings["Logging:LogPath"], rollOnFileSizeLimit:true,fileSizeLimitBytes:100000)
        .CreateLogger();

    return Host.CreateDefaultBuilder(args)
    .ConfigureAppConfiguration(config =>
    {
        config.AddConfiguration(configSettings);
    })
    .ConfigureLogging(logging =>
    {
        logging.AddSerilog();
    })
    .ConfigureWebHostDefaults(webBuilder =>
    {
        webBuilder.UseStartup();
    });

}

Step 3: Writing the log to the file

For a web application, use an object of ILogger which can be retrieved from the DI container as shown below

//declare a private variable
private readonly ILogger _logger;

//assign the object got from the DI container in the constructor
public HomeController(ILogger logger)
{
    _logger = logger;
}

If you run the application now and access the home page you will see the information is writing into the log file and rollover is happening automatically. The provider will automatically archive the file by appending a running sequence number to the file name.

ex.log 
ex_001.log 
ex_002.log 
ex_003.log

Rolling Policies

Log file per day

If you want to configure rollover for a period, say for a day or month, you will need to set up the interval as shown below

Log.Logger = new LoggerConfiguration()
    .WriteTo.File(configSettings["Logging:LogPath"], rollingInterval: RollingInterval.Day)
    .CreateLogger();

This setting will create a log file per day

Limits

When you set up rolling interval periods, be it for size or period, there are some default values

By default, the size of the file is capped at 1 GB, so if are not limiting the file size it will grow up to 1 GB

.WriteTo.File(configSettings["Logging:LogPath"], rollingInterval: RollingInterval.Day, fileSizeLimitBytes:100000)

Only the most recent 31 files are retained by default, you can override it by using retainedFileCountLimit

.WriteTo.File(configSettings["Logging:LogPath"], rollingInterval: RollingInterval.Day, retainedFileCountLimit: 100)

Implementing Logging in a .NET Core Web Application using Serilog

Wed, 08 Jan 2020 16:51:00 GMT

Setting up default logging

Create a new MVC application from Visual Studio. By default, Logging is enabled in the application via the ILogger interface. It has got some built-in providers for writing the log information to the console, event log as well as for third-party providers such as NLog, Serilog, etc.

For example, if you want to write logging information to the console window or event log, you will need to configure it in the CreateDefaultHostBuilder method in the Program.cs file as shown below.

 public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
    .ConfigureLogging(logging =>
    {
        logging.AddConsole();
        logging.AddEventLog();
    })
    .ConfigureWebHostDefaults(webBuilder =>
    {
        webBuilder.UseStartup();
    });

In the case of a web app, you will get an ILogger from the DI container and use that object for writing into the configured log providers. Let's see how we can do that in the HomeController

First, create a private variable for the logger interface.

private readonly ILogger<HomeController> _logger;

Then modify the constructor as shown below

public HomeController(ILogger logger)
{
    _logger = logger;
}

Now, use the LogInformation method available in the logger interface to write a message into the log

public IActionResult Index()
{
    _logger.LogInformation("Writing to log");
    return View();
}

If we run the application and goto the home page now, you will see this message written to the console.

To write an error, we normally use LogError method as shown below

public IActionResult Index()
{
    _logger.LogInformation("Writing to log");
    _logger.LogError("Error from Serlog sample");
    return View();
}

And the output will be

Implementing Serilog to log in a flat-file

First, you will need to install the necessary packages given below.

Install-Package Serilog
Install-Package Serilog.Extensions.Logging
Install-Package Serilog.Sinks.File

Modify the appsettings.json file to include the path for the log file

"Logging": {
    "LogPath": "logs//ex.log",
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },

Then modify the Program.cs file to read these values from the JSON file

var configSettings = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();

.ConfigureAppConfiguration(config =>
{
    config.AddConfiguration(configSettings);
})

Now, to hook up Serilog provider, import the namespace first and then modify CreateHostBuilder method to set up the logger

using Serilog

Log.Logger = new LoggerConfiguration()

    .WriteTo.File(configSettings["Logging:LogPath"])
    .CreateLogger();

.ConfigureLogging(logging =>
{
    logging.AddSerilog();
})

Here's the method is full

public static IHostBuilder CreateHostBuilder(string[] args)
{
    var configSettings = new ConfigurationBuilder()
        .AddJsonFile("appsettings.json")
        .Build();

    Log.Logger = new LoggerConfiguration()

        .WriteTo.File(configSettings["Logging:LogPath"])
        .CreateLogger();

    return Host.CreateDefaultBuilder(args)
    .ConfigureAppConfiguration(config =>
    {
        config.AddConfiguration(configSettings);
    })
    .ConfigureLogging(logging =>
    {
        logging.AddSerilog();
    })
    .ConfigureWebHostDefaults(webBuilder =>
    {
        webBuilder.UseStartup();
    });

}

Now if we run the application, you will see the information being written to the file mentioned in the path.

Generate Help Pages for your ASP.NET Core Web Api using Swagger

Sat, 14 Sep 2019 07:00:00 GMT

For any Web API developers, documenting your API and its methods is of paramount importance. Because these are intended to be consumed third parties, they will find it hard to incorporate it without any proper documentation. Creating a document is a very tedious and time-consuming job and most of the developers are least worried about it. This is where tools like Swagger which can automatically generate the documentation for you by examining your API code.

Adding Swagger

To set it up, you will need to add the below package to your project. This is can be done using the NuGet Package Manager in Visual Studio or by executing the following command in the Package Manager Console window

Install-Package Swashbuckle.AspNetCore

This package will add the following components

Swashbuckle.AspNetCore.Swagger : Middleware used to expose Swagger Document as a JSON endpoint
Swashbuckle.AspNetCore.SwaggerGen : a generator that builds the Swagger Document by looking into your controllers and action methods
Swashbuckle.AspNetCore.SwaggerUI : interprets the JSON outputted by the endpoint and builds an interactive UI

Configuring Swagger in your API Project

Adding and configuring Swagger is done in the Program class, first, you will need to import the following namespace

using Microsoft.OpenApi.Models;

Then in the ConfigureServices method, register the Swagger generator and define a document

services.AddSwaggerGen(c =>
 {
     c.SwaggerDoc("v1", new OpenApiInfo { Title = "Swagger Sample API V1", Version = "v1" });
 });

In the Configure method, add the two statements given below. The first one will enable the middleware to serve the generated document and the second one this document to show the interactive UI

//enables middleware
app.UseSwagger();

//enables SwaggerUI middleware to serve the UI for documentation
//and also specified the Swagger JSON endpoint
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "Swagger Sample API V1");
});

Here's the Configure method in full

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseSwagger();

    app.UseSwaggerUI(c =>
    {
        c.SwaggerEndpoint("/swagger/v1/swagger.json", "Swagger Sample API V1");
    });


    app.UseHttpsRedirection();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Accessing Swagger UI

You can access the UI by appending "swagger" to the root URL. For example, if you run the project just created, the interactive documentation will look like the one given below

Serializing enums as strings using System.Text.Json library in .NET Core 3.0

Fri, 30 Aug 2019 09:07:00 GMT

.NET Core 3.0 uses the System.Text.Json API by default for JSON serialization operations. Prior versions of .NET Core relied on JSON.NET, a third party library developed by Newtonsoft and the framework team decided to create a brand new library that can make use of the latest features in the language and the framework.

The new library has got support for all the new features that got introduced in the latest version of C#. And this was one of the main reasons behind the development of the new library because implementing these changes in JSON.NET meant a significant rewrite.

While serializing an object into JSON using the new library we can control various options such as casing, indentation, etc, but one notable omission is the support for enums by default. If you try to serialize an enum in .NET Core 3.0 with the default library, it will convert it into an integer value instead of the name of the enum.
For example, let consider the following model and see if what happens when we serialize it using the System.Text.Json library

public enum AddressType
{        
    HomeAddress,
    OfficeAddress,
    CommunicationAddress
    }

public class Employee
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public AddressType CommunicationPreference { get; set; }
}

and when you serialize it using the serialize method

List employees = new List{
    new Employee{
        FirstName = "Amal",
        LastName ="Dev",
        CommunicationPreference = AddressType.HomeAddress
    },
    new Employee{
        FirstName = "Dev",
        LastName ="D",
        CommunicationPreference = AddressType.CommunicationAddress
    },
    new Employee{
        FirstName = "Tris",
        LastName ="Tru",
        CommunicationPreference = AddressType.OfficeAddress
    }
}

JsonSerializer.Serialize(employees);

it will produce an output like the one given below

[ 
   { 
      "FirstName":"Amal",
      "LastName":"Dev",
      "CommunicationPreference":0
   },
   { 
      "FirstName":"Dev",
      "LastName":"D",
      "CommunicationPreference":2
   },
   { 
      "FirstName":"Tris",
      "LastName":"Tru",
      "CommunicationPreference":1
   }
]

If you look closely at the output string, the CommunicationPreference property has integer values instead of the names. In some scenarios, say if you are trying to give it as an output of an API method call it is not desirable to give back these integer values which can be meaningless. To overcome this, you can make use of a converter available in the library to do the conversion for you. To use this, instantiate an object of the JsonSerializerOptions and specify the converter there. And when you call the serialize method, pass this object also into that method as shown below

JsonSerializerOptions options = new JsonSerializerOptions{
    Converters ={
        new JsonStringEnumConverter()
    }
};

JsonSerializer.Serialize(employees, options);

Now the generated output will be

[
   {
      "FirstName":"Amal",
      "LastName":"Dev",
      "CommunicationPreference":"HomeAddress"
   },
   {
      "FirstName":"Dev",
      "LastName":"D",
      "CommunicationPreference":"CommunicationAddress"
   },
   {
      "FirstName":"Tris",
      "LastName":"Tru",
      "CommunicationPreference":"OfficeAddress"
   }
]

You will see now that our property is correctly displaying the names of the enums which is done automatically by the converter we added. By default, the library converts the strings to Pascal Case instead of the camelCase which is the most widely used format in JSON. You can control this behavior by specifying the format while hooking up the converter to the serializer

JsonSerializerOptions options = new JsonSerializerOptions{
    Converters ={
        new JsonStringEnumConverter( JsonNamingPolicy.CamelCase)
    },
    
};

And now, the output will be

[
   {
      "FirstName":"Amal",
      "LastName":"Dev",
      "CommunicationPreference":"homeAddress"
   },
   {
      "FirstName":"Dev",
      "LastName":"D",
      "CommunicationPreference":"communicationAddress"
   },
   {
      "FirstName":"Tris",
      "LastName":"Tru",
      "CommunicationPreference":"officeAddress"
   }
]

Deserializing Enums as Strings

We can use the same converter for doing deserialization also. If we try to deserialize a incoming payload that contains a string value instead of integer value for an enum the compiler value will throw JSON exception

string emp="[{\"FirstName\":\"Amal\",\"LastName\":\"Dev\",\"CommunicationPreference\":\"HomeAddress\"},{\"FirstName\":\"Dev\",\"LastName\":\"D\",\"CommunicationPreference\":\"CommunicationAddress\"},{\"FirstName\":\"Tris\",\"LastName\":\"Tru\",\"CommunicationPreference\":\"OfficeAddress\"}]";

Unhandled exception. System.Text.Json.JsonException: The JSON value could not be converted to JsonTextApi.AddressType. Path: $[0].CommunicationPreference

But, if provide an integer value instead of string for the enum, the serializer will deserialize it as expected If you want to use the string value, then add the converter while calling the Deserialize method as we did for the serialization operation.

JsonSerializerOptions options = new JsonSerializerOptions{
    Converters ={
        new JsonStringEnumConverter( JsonNamingPolicy.CamelCase)
    },

};

JsonSerializer.Deserialize<List>(emp,options).ForEach(x=> Console.WriteLine($"{x.FirstName} {x.LastName}, {x.CommunicationPreference}"));

Output

Amal Dev, HomeAddress
Dev D, CommunicationAddress
Tris Tru, OfficeAddress

Part 1 : Serializing and Deserializing Json in .NET Core 3.0 using System.Text.Json API

Part 2: Step-By-Step Guide to Serialize and Deserialize JSON Using System.Text.Json

Part 3: Avoid conversion errors by using Custom Converters in System.Text.Json API

Avoid conversion errors by using Custom Converters in System.Text.Json API(.NET Core 3.0)

Wed, 14 Aug 2019 06:07:00 GMT

The post is based on .NET Core 3.0
SDK used : 3.0.100

One of the most common error encountered while doing JSON serialization and deserialization is the data type conversion errors. Till now, we were using the Json.NET library from Newtonsoft for performing the serialization and deserialization in .NET/ASP.NET/.NET Core, but in the latest iteration of .NET Core which is currently under preview, they have removed the dependency on Json.NET and introduced a new built-in library for doing the same. Along with that, the all new library that is going to be introduced with .NET Core 3.0 provides you to define custom converters that can be implemented to get rid of this kind of errors. If you are not aware of it, I have already written a couple of posts about it which you can refer to using the following links.

Serializing and Deserializing Json in .NET Core 3.0 using System.Text.Json API

Step-By-Step Guide to Serialize and Deserialize JSON Using System.Text.Json

The new API is included with the System namespace and you don't need to add any NuGet package to get started with it. Along with the normally used methods for serializing/deserializing JSON, it also includes methods for supporting asynchronous programming. One of the known limitation in the v1 of the API is the limited support for the data types, given below is the list of currently supported types. For more detail, please refer this link Serializer API Document

Array

Boolean

Byte

Char (as a JSON string of length 1)

DateTime

DateTimeOffset

Dictionary<string, TValue> (currently just primitives in Preview 5)

Double

Enum (as integer for now)

Int16

Int32

Int64

IEnumerable

IList

Object (polymorhic mode for serialization only)

Nullable < T >

SByte

Single

String

UInt16

UInt32

UInt64

Also, by design, any support for type coercion/inference is not included by default. For example, if we are trying to convert a boolean value stored as a string in the JSON to a boolean type, the serializer will throw an error during the deserializing operation. To illustrate this, let's consider the below JSON

[
    {
        "Id": 1026,
        "Name": "Echo Dot",
        "Description": "Smart speakers from Amazon",
        "IsInStock": "false"
    },
    {
        "Id": 8084,
        "Name": "Chromecast",
        "Description": "Stream content to TV",
        "IsInStock": "true"
    },
    {
        "Id": 9096,
        "Name": "iPhone",
        "Description": "Latest one from Apple",
        "IsInStock": "false"
    }
]

And I have defined a class like the one below

class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public DateTime LastUpdatedOn { get; set; }
        public bool IsInStock { get; set; }
    }

If we try to deserialize using the following statement, the API will throw an error as shown below

JsonSerializer.Deserialize<List<Product>>(productList, options);

Unhandled exception. System.Text.Json.JsonException: The JSON value could not be converted to System.Boolean. Path: $[0].IsInStock | LineNumber: 5 | BytePositionInLine: 25.
 ---> System.InvalidOperationException: Cannot get the value of a token type 'String' as a boolean.

In the JSON, for the "IsInStock" attribute the value is stored as a string and we are trying to map that attribute to a boolean property in the Product class using the Deserialize method in the API.

Complete code

ConverterSample.cs

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Collections.Generic;

namespace JsonTextApi
{

    class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public DateTime LastUpdatedOn { get; set; }
        public bool IsInStock { get; set; }
    }
    class ConverterSample
    {
        public List<Product> DeserializeData(string productList)
        {
           
            return JsonSerializer.Deserialize<List<Product>>(productList);
        }
        

    }
}

Program.cs

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.IO;
using System.Collections.Generic;

namespace JsonTextApi
{
    class Program
    {
        static void Main(string[] args)
        {
            
            ConverterSample obj = new ConverterSample();
            var objProduct = new Product();

            var productJson = File.ReadAllText("input.json");
            Console.WriteLine(productJson);
            Console.ReadLine();
            var items = obj.DeserializeData(productJson);
            
            
            foreach(var item in items)
            {
                Console.WriteLine($"{item.Id}, {item.Name}, {item.IsInStock}");
            }
            Console.ReadLine();            
        }

    }
}

This is happening because, as I already mentioned the API doesn't do these sort of conversions by default. But in most of the circumstances, the consuming applications don't have control over the type or format of the data. So to handle this kind of situations, one may need to implement custom converters to handle the job for you. It's very to easy to create and hookup converters using the System.Text.Json API.

Using Custom Converters

Let's create a custom converter to convert the value stored as string in the JSON to a boolean type.

Step 1: Create a class by inheriting from JsonConverter<T> class available in the System.Text.Json.Serialization namespace where T is the type you want to convert to.

public class BooleanConverter : JsonConverter<bool>

Step 2: Override the Read method to handle the deserialization of the incoming JSON string. Here, the conversion will happen if the value in the string is either "True", "true", "1", "False", "false", "0", the first three will resolve to boolean true and rest to boolean false

        public override bool Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            string value = reader.GetString();
            string chkValue = value.ToLower();
            if (chkValue.Equals("true") ||chkValue.Equals("yes") || chkValue.Equals("1") )
            {
                return true;
            }
            if (value.ToLower().Equals("false") ||chkValue.Equals("no") || chkValue.Equals("0"))
            {
                return false;
            }
            throw new JsonException();

        }

Step 3: Similarly, Override the Write method if you want to convert the boolean value to a string while doing serialization

 public override void Write( Utf8JsonWriter writer, bool value, JsonSerializerOptions options)
        {
            switch (value)
            {
                case true:
                    writer.WriteStringValue("true");
                    break;
                case false:
                    writer.WriteStringValue("false");
                    break;
              
            }

        }

Step 4: Wire our converter method to the API. We can do that in multiple ways, either we can register the converter through JsonSerializerOptionsor by placing the [JsonConverter] on the property as shown below.

var options  = new JsonSerializerOptions();
options.Converters.Add(new BooleanConverter());

[JsonConverter(typeof(BooleanConverter))]
public bool IsInStock { get; set; }

Let's go for the first approach and see how it solves the problem. Let's modify the DeserializeData method shown in the first part as below

        public List<Product> DeserializeData(string productList)
        {
             var options  = new JsonSerializerOptions();
             options.Converters.Add(new BooleanConverter());

            return JsonSerializer.Deserialize<List<Product>>(productList,options);
        }

Here's the code in full

ConverterSample.cs

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Collections.Generic;

namespace JsonTextApi
{

    class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public DateTime LastUpdatedOn { get; set; }
        public bool IsInStock { get; set; }
    }
    class ConverterSample
    {
        public List<Product> DeserializeData(string productList)
        {
             var options  = new JsonSerializerOptions();
             options.Converters.Add(new BooleanConverter());

            return JsonSerializer.Deserialize<List<Product>>(productList,options);
        }
        public string SerializeData(List<Product>  productList)
        {
            var options  = new JsonSerializerOptions() {WriteIndented = true };
            options.Converters.Add(new BooleanConverter());

            return JsonSerializer.Serialize<List<Product>>(productList, options);
        }

    }
}

Program.cs

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.IO;
using System.Collections.Generic;

namespace JsonTextApi
{
    class Program
    {
        static void Main(string[] args)
        {
            ConverterSample obj = new ConverterSample();
            var objProduct = new Product();
            //input json is read from the file
            var productJson = File.ReadAllText("input.json");
            Console.WriteLine(productJson);
            Console.ReadLine();
            var items = obj.DeserializeData(productJson);
            
            foreach(var item in items)
            {
                Console.WriteLine($"{item.Id}, {item.Name}, {item.IsInStock}");
            }

        }

    }
}

Output

INPUT STRING
=====================
[
    {
        "Id": 1026,
        "Name": "Echo Dot",
        "Description": "Smart speakers from Amazon",
        "IsInStock": "no"
    },
    {
        "Id": 8084,
        "Name": "Chromecast",
        "Description": "Stream content to TV",
        "IsInStock": "yes"
    },
    {
        "Id": 9096,
        "Name": "iPhone",
        "Description": "Latest one from Apple",
        "IsInStock": "no"
    }
]

DESERIALIZED DATA
=====================
1026, Echo Dot, False
8084, Chromecast, True
9096, iPhone, False

Similarly, for serializing the data, you can hook up the convertor to JsonSerializerOptions object and pass it on to the Serialize method. Please refer to the SerializeData method in the ConverterSample.cs give above for the implementation.

Part 1 : Serializing and Deserializing Json in .NET Core 3.0 using System.Text.Json API

Part 2: Step-By-Step Guide to Serialize and Deserialize JSON Using System.Text.Json

Step-By-Step Guide to Serialize and Deserialize JSON Using System.Text.Json

Wed, 10 Jul 2019 15:43:00 GMT

The post is based on .NET Core 3.0 version.

Update : In preview 7 few changes were made to the API. For serialization use Serialize method instead of ToString and Deserialize method instead of Parse. Post updated to reflect these changes. SDK version : 3.0.100-preview7-012821

In the last post, I have already given an overview of the System.Text.Json API that is going to be introduced with the release with .NET Core 3.0. This API will replace the Json.NET library by Newtonsoft which is baked into the framework for doing serialization and deserialization of JSON. You can read more about it using this link.

Step 1: Refer the namespaces

Add the following lines in your code. If you are working .NET Core 3 project, then there is no need to add any NuGet packages to your project. For .NET Standard and .NET Framework project, install the System.Text.Json NuGet package. Make sure that Preview is enabled and select install version 4.6.0-preview6.19303.8 or higher

using System.Text.Json;
using System.Text.Json.Serialization;

Step 2: Serializing an object into JSON string

Serialization is the process of converting an object into a format that can be saved. JSON is one of the most preferred format for encoding object into strings. You will be able to do this conversion by calling the ToString method in the JsonSerializer class available in the System.Text.Json API

For example, to convert a Dictionary object to a JSON string we can use the following statement

JsonSerializer.ToString<Dictionary<string,object>>(dictObj)

Code Snippet

using System;
using System.Text.Json;
using System.Text.Json.Serialization;

using System.Collections.Generic;

namespace JsonTextApi
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string,object> dictObj = new Dictionary<string,object>();

            dictObj.Add("name","Amal");
            dictObj.Add("age",20);
            dictObj.Add("country","India");
            
            Console.WriteLine("\nJSON Object");
            Console.WriteLine("=========================\n");
            foreach(var item in dictObj )
            {
                    Console.WriteLine($"{item.Key} -> {item.Value}");
            }
            Console.WriteLine("\nConverting back to text");
            Console.WriteLine("=========================\n");
            Console.WriteLine(JsonSerializer.ToString<Dictionary<string,object>>(dictObj));
            Console.ReadLine();
        }
    }
}

Output

Step 3: Deserializing JSON

Deserialization is the process of converting a string in JSON format to a custom data type. Consider the following JSON string which has got three properties namely name, age, and country that needs to be converted to a Dictionary object

{ "name":"Amal", "age":20 , "country": "India" }

For that, we can make use of the Parse method available in the JsonSerializer class as shown below

var items = JsonSerializer.Parse<Dictionary<string,object>>(jsonString);

The above statement will convert the string into a Dictionary object and we will be able to refer these using the Key and Value properties. Full code is given below along with the output.

Code Snippet

using System;
using System.Text.Json;
using System.Text.Json.Serialization;

using System.Collections.Generic;

namespace JsonTextApi
{
    class Program
    {
        static void Main(string[] args)
        {
            var jsonString = "{ \"name\":\"Amal\", \"age\":20 , \"country\": \"India\" }";
            Console.WriteLine("\nInput String");
            Console.WriteLine("=========================\n");
            Console.WriteLine(jsonString);
            Console.WriteLine("\nConverting text");
            Console.WriteLine("========================\n");
            var items =JsonSerializer.Parse<Dictionary<string,object>>(jsonString);
            foreach(var item in items)
            {
                    Console.WriteLine($"{item.Key} -> {item.Value}");
            }
            Console.ReadLine();

        }
    }
}

Output

Part 1 : Serializing and Deserializing Json in .NET Core 3.0 using System.Text.Json API

Serializing and Deserializing Json in .NET Core 3.0 using System.Text.Json API

Wed, 03 Jul 2019 07:20:00 GMT

The post is based on .NET Core 3.0 version

Last October, the .NET Core team at Microsoft has announced that they are stripping out Json.Net, a popular library used by developers for serializing and deserializing the JSON from the upcoming version of the framework. Along with that, they also announced that they are working on a new namespace System.Text.Json in the framework for doing the same. With the release of the latest preview version of .NET Core 3.0, developers will now be able to make use of this namespace for performing JSON operations.

The new namespace comes as part of the framework and there is no need to install any NuGet packages for using it. It has got the support for a reader, writer, document object model and a serializer.

Why a new library now?

JSON is one of the most widely used formats for data transfer especially from the client-side, be it web, mobile or IoT to the server backends. Most of the developers using the .NET Framework were relying on popular libraries like Json.NET because of the lack of the out of the box support provided by Microsoft.

One of the major reasons to develop a new library was to increase the performance of the APIs. To integrate the support for Span<T> and UTF-8 processing into the Json.NET library was nearly impossible because it would either break the existing functionality or the performance would have taken a hit

Even though Json.NET is getting updated very frequently for patches and new features, the tight integration with the ASP.NET Core framework meant these features got into the framework only when an update to the framework is released. So the .NET team has decided to strip the library from the framework and the developers will now be able to add it as a dependency in .NET core 3.0 meaning they will be free to choose whichever version of the Json.NET library they want

Now the developers has got two options for performing the Json operations, either use System.Text.Json namespace or use Json.NET library which can be added as a NuGet package and using AddNewtonsoftJson extension method.

Referring the library in your projects

.NET Core
To use it in a .NET Core project, you will need to install the latest preview version of .NET Core.

.NET Standard, .NET Framework
Install the System.Text.Json package from NuGet, make sure that you select Includes Preview and install version 4.6.0-preview6.19303.8 or higher

As of now, the support for OpenAPI / Swagger is still under development and most probably won't make be available in time for .NET Core 3.0 release.

Reference : Try the new System.Text.Json APIs

Part 2 : Step-By-Step Guide to Serialize and Deserialize JSON Using System.Text.Json

Breaking Changes coming your way for ASP.NET Core 3.0

Thu, 31 Jan 2019 19:42:00 GMT

Microsoft is in the process of releasing a new version for their .NET Core framework and there are some significant changes coming your way in that release. The most important ones are

Removal of some sub-components
Removal of the PackageReference to Microsoft.AspNetCore.App
Reducing duplication between NuGet packages and shared frameworks

In v3.0, the ASP.NET Core framework will contain only those assemblies which are fully developed, supported and serviceable by Microsoft. They are doing this to reap all the benefits provided by the .NET Core shared frameworks like smaller deployment size, faster bootup time, centralized patching etc

Removal of some sub-components

In this version, they are removing some sub-components from the ASP.NET Core shared framework and most notable among them are the following

Json.NET

JSON format has become so popular these days and has become the primary method for transferring data in all modern applications. But .NET doesn't have a built-in library to deal with JSON and relied on third-party libraries like JSON.NET for some time now. In ASP.NET Core, it has a tight integration with Json.NET which restricted the users to chose another library or a different version of Json.NET itself.

So with version 3.0 they have decoupled Json.NET from the ASP.NET Core shared framework and is planning to replace it with high-performance JSON APIs. That means you will now need to add Json.NET as a separate package in you ASP.NET Core 3.0 project

and then update your ConfigureServices method to include a call to AddNewtonsoftJson() as shown below

public void ConfigureServices(IServiceCollection services)
{
           services.AddMvc()
               .AddNewtonsoftJson();
}

Entity Framework Core

Entity Framework will ship purely as a NuGet package in ASP.NET Core 3.0 in line with the shipping model of all other data access libraries on .NET which helps to bring out new features as and when is done instead of waiting for the release of the next version of the shared framework. Also, even though it has moved out of the shared framework, it will retain the status as a library which is fully developed and supported by Microsoft.

Roslyn

Most of us will make updates to views or pages and preview the changes in the browser without restarting the server. With this cleaning up of the shared framework also meant to drop the usage of Rosyln which supported the runtime compilation of the pages and views. Now the compilation will happen at the build time and if you want to preview changes you may need to rebuild it and run the application again. They are planning to bring in NuGet packages for optionally enabling runtime compilation in the future preview updates.

Removal of PackageReference to Microsoft.AspNetCore.App

In the versions prior to 3.0, references to Microsoft.AspNetCore.App was added as a PackageReference in your csproj file

<ItemGroup>
      <PackageReference Include="Microsoft.AspNetCore.App" />
</ItemGroup>

In 3.0, the SDK will introduce a new item called <FrameworkReference> which is going to replace the <PackageReference> tag

<ItemGroup> 
     <FrameworkReference Include="Microsoft.AspNetCore.App" /> 
</ItemGroup>

Reducing duplication between NuGet packages and shared frameworks

With these incoming changes to the shared frameworks, now there is no need to add the assemblies in the Microsoft.AspNetCore.App as NuGet packages when you consume it in your packages. That meant

https://github.com/aspnet/Announcements/issues/325

https://github.com/aspnet/AspNetCore/issues/3612

https://github.com/dotnet/announcements/issues/90

https://blogs.msdn.microsoft.com/webdev/2018/10/29/a-first-look-at-changes-coming-in-asp-net-core-3-0/

https://github.com/aspnet/announcements/issues?q=is%3Aopen+is%3Aissue+milestone%3A3.0.0

Resilient Connections in Entity Framework Core

Fri, 05 Oct 2018 05:18:00 GMT

When you work with databases in your application, you may face connection issues from time to time which is beyond our control. When this happens normally the application will raise a connection timeout or server not available exception. In Entity Framework core you can overcome this kind of scenario by setting up resilient connections with exponential retries.

The code snippet given below will retry to connect up to 10 times in case of a failure with a delay of 30 seconds in-between each try.

services.AddDbContext(o =>
{
    o.UseSqlServer(connectionString,
        sqlServerOptionsAction: options =>
        {
            options.EnableRetryOnFailure(maxRetryCount: 10,
                maxRetryDelay: TimeSpan.FromSeconds(30),
                errorNumbersToAdd: null);
        });
});

Also, when you enable retries in EF Core connections, each operation you perform will become its own retriable operation. So that means whenever we perform a query or a call to the SaveChanges method, it will be retried as a unit during a transient failure scenario. But when you initiate a transaction block in your code using BeginTransaction, then you are defining your own group that needs to treated as a single unit.

So, in this case, you will need to manually invoke an execution strategy with a delegate method that contains all that need to be executed as a block. So, when a transient failure occurs, the execution strategy will invoke the delegate again as part of the retry operation.

var strategy = blogContext.Database.CreateExecutionStrategy();
await strategy.ExecuteAsync(async () =>
{

    using (var transaction = blogContext.Database.BeginTransaction())
    {
        blogContext.PostItems.Update(postItem);
        await blogContext.SaveChangesAsync();


        if (raisePostChangedEvent)
        await eventLogService.SaveEventAsync(postChangedEvent);
        transaction.Commit();
    }

Reference : https://docs.microsoft.com/en-us/dotnet/standard/modern-web-apps-azure-architecture/work-with-data-in-asp-net-core-apps

Deploying Resources to Azure using Azure Resource Manager Templates - Part #3

Tue, 24 Jul 2018 05:18:00 GMT

In the previous post, I had already explained the steps that are needed for deployment in Azure using an empty template. Let's explore further and see how we can deploy a storage account in Azure using ARM Templates.

Step 1: Create the template file

Open any text editor and create a template like the one given below. Save it as a JSON file with name StorageTemplate.json
What we are doing with this template is that we have defined two parameters named storageName and storageLocation for accepting the name of the resource as well as the location where it needs to be provisioned

And, under the resource section, we will use these parameters to set the name and the location properties for the storage account. Also, we will set the values for the resource type, kind and SKU

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.1",
    "parameters": {
        "storageName": {
            "type": "string"
        },
        "storageLocation": {
            "type": "string"
        }
    },
    "variables": {},
    "resources": [
        {
          "apiVersion": "2016-01-01",
          "type": "Microsoft.Storage/storageAccounts",
          "name":  "[parameters('storageName')]",
          "location": "[parameters('storageLocation')]",  
          "sku": {
            "name": "Standard_LRS"
          },
          "kind": "Storage",
          "properties": {
          }
        }
   
    ],
    "outputs": {}
}

Step 2: Deploy the template using Azure CLI

Open up Powershell/Command prompt and execute the following command. Make sure that Azure CLI is already installed in your machine and configured to access your Azure subscription

az group deployment create --name EmptyARMDeployment --resource-group TechRepResGrp --template-file .\storage-template.json --parameters storageName=storagedemoO365 storageLocation=SouthIndia

This command is very much similar to the one we used in the earlier post, the only difference is that we supplied the values for the parameters that will be used by the template to provision the storage account

Deploy to Azure using an Empty Azure Resource Manager Templates - Part #2

Tue, 10 Jul 2018 19:42:00 GMT

In the earlier post, I went through the basic concepts and terminologies for deploying resources using the Azure Resource Manager(ARM) templates. Please refer it using this link for quick reference. In this post, I will show you how to perform a deployment using an empty ARM template.

Step 1: Create an empty template

Create an empty template like the one given below using any text editor. Save as a JSON file with any name you want. In my case, I named it as EmptyTemplate.json

{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
  },
  "variables": {
  },
  "resources": [
  ],
  "outputs": {
  }
}

Step 2: Configure Azure CLI

I am going to use Azure CLI for doing the deployment. Before you start deploying, make sure that your local machine has got Azure CLI installed and configured correctly. Azure CLI is a cross-platform tool is available for download from here, which helps you to connect to your Azure subscription and execute various commands to manage and monitor it.

The best way to verify it's installed or not by executing the below command.

az --version

If everything is fine with your machine, we can move on and connect to an Azure subscription using,

az login

When this command is executed, it will give you a code which needs to be entered into a page using the URL provided in the message from the browser. Once you submit that, your request will be authenticated and will show the list of subscription(s) upon successful operation

Step 3: Create a resource group

As I mentioned in the earlier post, every resource must reside in a resource group in Azure. For that, let's create one

az group create --name TechRepResGrp --location "South India"

Step 4: Deploy using Empty Template

Now in the PowerShell window, go to the folder where you have saved the template file and execute the below command.

az group deployment create --name EmptyARMDeployment --resource-group TechRepResGrp --location "South India" --template-file EmptyTemplate.json

This will create a deployment with the mentioned name in the resource group provided in the command. You can verify it by going to the portal and see our's under the Deployment section.

Since we used an empty template it won't be creating any resources. So in the next post, I will guide you to provision various resources using ARM templates.

Deploying Resources to Azure using Azure Resource Manager Templates - Part #1

Wed, 04 Jul 2018 15:43:00 GMT

A component provisioned in Azure can contain a set of resources, say for example a Virtual Machine in Azure can have components such as Storage Accounts, Virtual Networks, IP address etc. And most of the times you may want to manage, deploy and delete these interdependent resources as a single entity. Azure Resource Manager(ARM) will help you to work with these resources in a single, coordinated operation.

ARM supports various tools for interacting with its management layer, the most used ones include Azure CLI, Azure Powershell, REST APIs, and Azure Cloud Shell. The portal gets the newly released functionalities with 180 days of the initial release.

The tools interact with the Azure Resource Manager API, which then passes it to the Resource Manager Service to perform the authentication and authorization of the request. Once this is completed, the Resource Manager then routes the request to the appropriate service for performing the requested operation.

Source: docs.microsoft.com

Glossary

Resource: is a manageable item in Azure. Typical examples include web app, database, IP address, virtual machine etc

Resource Group: is a container that holds the resources. A resource can belong only on one resource group. It is possible to add/delete resources from a resource group at any time and is also possible to move from one group to another. Also, it can reside in different regions too

Resource Provider: A resource provider offers a set of operations and resources for working with an Azure service. Examples include Microsoft.Compute, Microsoft.Web, Microsoft.Storage.

Resource Manager Template: is a file in JSON format which contains a declarative syntax for defining the infrastructure as well as configuration for your solution. This file will help you to deploy your resources repeatedly and in a consistent manner.

ARM Template Format

Given below is the barebone format for the template and of the keys among it, only $schema and contentVersion is mandatory

$schema: specifies the location of the schema file which defines the version of the template language

contentVersion: specifies the version of the template file. You can give any number in there which can be used to document the changes made to the template

parameters: specifies the values that can be provided during deployment

variables: values that are used in the template for simplifying language expressions in the template

functions: user-defined functions available in the template

resources: Resources that are going to be created/updated during the deployment

outputs: values that can be returned after the deployment

{
    "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "",
    "parameters": {  },
    "variables": {  },
    "functions": {  },
    "resources": [  ],
    "outputs": {  }
}

Sample Template File

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.1",
    "parameters": {
        “resourceGroupName": {
            "type": "string"
        },
        "resourceGroupLocation": {
            "type": "string"
        }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Resources/resourceGroups",
            "apiVersion": "2018-05-01",
            "location": "[parameters('resourceGroupLocation')]",
            "name": "[parameters('resourceGroupName')]",
            "properties": {}
        }
    ],
    "outputs": {}
}

These can be deployed using various tools such as Azure Powershell, Azure CLI, Azure Portal/Cloud Shell, REST APIs. In the next post, I will show you how to use Azure CLI for doing the deployment.

Creating NuGet Package using .NET Core CLI

Wed, 06 Jun 2018 15:43:00 GMT

NuGet is a great tool in managing your third-party dependencies as well as in distributing your own libraries. The dotnet pack command available in .NET Core CLI toolset will help you to build the project and creates a NuGet package. The output of this command will be a .nupkg file which can be used to push to a public registry like nuget.org or to any other private registries.

Let's start with a .NET Core class library project and see how we can pack that using the CLI toolchain

dotnet new class --name SampleLib

It will create a new project with one file in C# inside it. Let's create a package using the below command

dotnet pack

When it's executed it will search for the project file in the current directory, then restores the dependencies, builds the project if it's found and packages it. If your project is in a different location then you need to specify the path along with the project name.

You can avoid the building of the project while creating the package by specifying the --no-build parameter along with the pack command

dotnet pack --no-build

From the above images, you will see that the version of the package is always 1.0.0, to change that use the PackageVersion parameter. Also, to create the package in a custom location, you can see make use of the --output parameter as shown below.

dotnet pack --output package /p:PackageVersion=2.0.0

Note: Please note that the dotnet pack command won't work for web projects by default in .NET Core 2.X. In some scenarios say while building a DevOps pipeline for your web application you may need to package your web project too. To enable this you will need to add the following snippet in your .csproj file

<PropertyGroup>
  <IsPackable>true</IsPackable>
</PropertyGroup>