First of all and before we go straight to deployment and demo let’s understand what is a reverse proxy .

A reverse proxy intercepts all incoming requests and direct them to the appropriate server ,it can play the role of Load Balancer ” a Traffic Cop ” that will distribute the clients requests across group of servers in order to maximizes speed and capacity and making sure that no server is overloaded (in case a server is down the load balancer will redirect the traffic to the other servers ) ,more than that a reverse proxy will protect the identity of the other servers and act as a defense againsts security attacks .In this sense the reverse proxy will make sure that multiple servers can be accessed only from a single URL .

Prerequisites

• Visual studio or visual studio code
• A command mine /Terminal
• Docker installed on your system

Part 1- Without Docker Compose

in this first part we will create our dotnet application that we will use now and later too , also nginx .
and we will go straight to our Index.cshtml  , and edit it to be like this :

@page
@model IndexModel

@{
    ViewData["Title"] = "Home page";
    var hostname = ViewData["host"];
}

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
    <p>
        <strong>Hostname :</strong> <h3> <code>@hostname</code></h3>
    </p>
</div>

Also we will edit the Index.cshtml.cs 

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using System.Net;

namespace hostnameapp.Pages
{
    public class IndexModel : PageModel
    {
        private readonly ILogger<IndexModel> _logger;
        [BindProperty]
        public string? hostname { get; set; }
        public IndexModel(ILogger<IndexModel> logger)
        {
            _logger = logger;
        }

        public void OnGet()
        {
            String hostName = Dns.GetHostName();
            Console.WriteLine(hostName);
            ViewData["host"] = hostName;
            

        }
    }
}

now if we run the application using IIS express we will have this view  :
As you can see the goal here is to show the hostname , nothing special .

now we will dockeriz application by creating a dockerfile  with this content (full source code of the solution will be shared )

FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine AS base

WORKDIR /app
ENV ASPNETCORE_URLS http://+:5000
# EXPOSE 80
EXPOSE 5000

FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /src
COPY ["hostnameapp/hostnameapp.csproj", "hostnameapp/"]
RUN dotnet restore "hostnameapp/hostnameapp.csproj"
COPY . .
WORKDIR "/src/hostnameapp"
RUN dotnet build "hostnameapp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "hostnameapp.csproj" -c Release -o /app/publish /p:UseAppHost=false

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "hostnameapp.dll"]

now we will create the nginx application but we have some config for the app :
we will create  a file : nginx.conf

worker_processes 4;
 
events { worker_connections 1024; }
 
http {
    sendfile on;
    limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;
    # upstream app_servers {
    #     #server app:127.0.0.1:5000;
    #   # server  http://backend:5000;
    # }
 
    server {
        listen 80;
 
        location / {
            proxy_pass          http://backend:5000;
            proxy_redirect     off;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Host $server_name;
        }
    }
}

Also we are going to docke the nginx proxy app

FROM nginx:alpine
RUN rm -r  /etc/nginx/nginx.conf
COPY nginx.conf /etc/nginx/nginx.conf

now we can build both apps and run them to see what will happen .

let’s start with our dotnet application we need to build and run our solution :

docker build -t backend  .
docker run -it --rm -p 5000:5000   --name backend backend

Now if you go to your browser and visit :  http://localhost:5000/ you will have this result :

And now as you can see our hostname have the id of the container .

now it’s time to run the nginx proxy that will be the entry to our application or let’s say the way we will expose our application .

docker build -t frontend  .
docker run -it --rm -p 8082:80   --name frontend frontend

if we run those commandes the project will build but will not run and we will finish by having an error saying that host not found , the host is the backend that we defined in the config file with port 5000 , and that’s because the two containers are not in the same network !
now let’s make some changes :
Let’s create a network :

docker network create demonetwork-001;
#to inspect that network 
docker network inspect demonetwork-001;

now we need to attach our containers to the network that we have created  :

docker network connect demonetwork-001 backend;
#this will fail because the container did exit beceause of error
docker network connect demonetwork-001 frontend;

--------------instead we will use this -------------------------
docker run -it --rm -p 5000:5000 --network=demonetwork-001  --name backend backend
docker run -it --rm -p 8082:80  --network=demonetwork-001  --name frontend frontend

and like that we will have our result  while visiting our entry point on port 8082 :

Part 2- With Docker Compose

now all we need is to create a docker compose file without editing our solutions : docker-compose.yml

version: "3.9"
services:
  app:
    build: ./hostnameapp
    expose: 
      - "5000"    
  proxy:
    #image: nginx:alpine
    build: ./nginx
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app
    links:
      - app  
    ports:
      - "8082:80"

now in our file we define the two apps and we say that the proxy app depends on the first app let see the result :
and this is our goal , we want the backend not to be exposed to public and we want our frontend exposed as you can see on port 8082 and we can not acces the backend , now if we modify the config file and add different backends with different port the load balancer will play it’s role to manage the traffic between the apps .

Now if we have the same app on different port and we edit the config file like this ofr example :

worker_processes 4;
 
events { worker_connections 1024; }
 
http {
    sendfile on;
 
    upstream app_servers {
        server app:5000 weight=4;
        server app2:5010 weight=2;
    }
 
    server {
        listen 80;
 
        location / {
            proxy_pass         http://app_servers;
            proxy_redirect     off;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Host $server_name;
        }
    }
}

the result will show that we balance between the two apps

that’s it for this demo , in next post we will discuss how we will do this on Azure Kubernetes Service (AKS) .

source code : https://bit.ly/3EDJVus

Hangfire is a .Net Library that help to perform background processing in .NET and .NET Core applications in a easy way .
No Windows Service or separate process required.
Backed by persistent storage. Open and free for commercial use.

In this article we are going to create a simple project and will be shared in GitHub repo .

Plan :

1-What is Hangfire
2-Background tasks in ASP.NET Core
3-Setup and Configure Hangfire
4-Secure the Hangfire Dashboard
5-Retention Time
6-Hangfire and SQL server

What is Hangfire :

Hangfire is an open-source framework that helps you to create, process and manage your background jobs, i.e. operations you don’t want to put in your request processing pipeline:

– mass notifications/newsletter  .
– batch import from xml, csv, json .
– creation of archives .
– firing off web hooks .
– deleting users .
– building different graphs .
– image/video processing .
– purge temporary files .
– recurring automated reports .
– database maintenance.

Hangfire supports all kind of background tasks – short-running and long-running, CPU intensive and I/O intensive, one shot and recurrent. You don’t need to reinvent the wheel – it is ready to use.
Hangfire is shipped with an awesome tool – Web Monitoring UI. It is implemented as an OWIN extension and can be hosted inside any application – ASP.NET, Console or Windows Service. Monitoring UI allows you to see and control any aspect of background job processing, including statistics, exceptions and background job history.

Background tasks in ASP.NET Core :

Background tasks and scheduled jobs are something you might need to use in any application,sometimes it is necessary to schedule and create long-running methods for our .NET Core applications.

Note  :

If you are using cloud you can use in Azure :

Azure WebJobs

A formal Azure feature used for offloading running of background tasks outside of your Website and scale the workload.

Azure Worker Role in a Cloud Service :

Scale the background processing workload independently of your Website and you need control over the machine .

Setup and Configure Hangfire

First we are going to create a new project than we are going to install few nuget packages to our project so we can use hangfire .

• Hangfire.AspNetCore  .
  Hangfire.SqlServer    .
  Hangfire.MemoryStorage .
  Hangfire.Dashboard.Basic.Authentication  .

Create Model : 

using System;  
using System.Collections.Generic;  
using System.ComponentModel.DataAnnotations;  
using System.Linq;  
using System.Threading.Tasks;  
  
namespace Hangfire.Model  
{  
    public class Student
    {  
        [Key]
        public int Id { get; set; }
        public string StudentName { get; set; }
        public string StudentProblem { get; set; } 
    }  
}

AppDbContext

using Hangfire.Model;  
using Microsoft.EntityFrameworkCore;  
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Threading.Tasks;  
  
namespace DemoHangfireNet5.AppDbContext
{
    public partial class StudentDbContext : DbContext
    {
        public StudentDbContext(DbContextOptions options) : base(options)
        {

        }
        public DbSet<Student> Students { get; set; }
    }
}

appsettings.json

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "myconnection": "Server=localhost; database=demo;Trusted_Connection=True;"
  }
}

Then we have to create the table using the below migration commands in the package manager console.

Creates migration folder and migration script inside the target project.

Add-Migration 'MigrationName1'  

The next command executes the migration script and creates a table in the database

Update-Database

Note : if you have problem with The term “Add-Migration” is not recognized  you ” , you should Just install Microsoft.EntityFrameworkCore.Tools package from nuget.

Services 

IStudentService.cs

namespace DemoHangfireNet5.Services
{
    public interface IStudentService
    {
        Task<bool> InsertStudentsAsync();
    }
}

   public class StudentService : IStudentService
    {
        #region Property  
        private readonly StudentDbContext _StudentDbContext;
        #endregion

        public StudentService(StudentDbContext StudentDbContext)
        {
            _StudentDbContext= StudentDbContext;
        }

        public async Task<bool> InsertStudentsAsync()
        {
            try
            {
                Student _Student = new Student()
                {
                    StudentName = "Alex",
                    StudentProblem = "Failing to network"

                };
                await _StudentDbContext.AddAsync(_Student);
                await _StudentDbContext.SaveChangesAsync();
                return true;
            }
            catch (Exception)
            {

                throw;
            }
        }
    } 

background tasks :

Jobs

using DemoHangfireNet5.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace DemoHangfireNet5.Jobs
{
    public class Job
    {
        #region Property
        private readonly IStudentService _IStudentService;
        #endregion

        #region Constructor
        public Job(IStudentService IStudentService)
        {
            _IStudentService = IStudentService;
        }
        #endregion

        #region Job Scheduler
        public async Task<bool> JobAsync()
        {
            var result = await _IStudentService.InsertStudentsAsync();
            return true;
        }
        #endregion
    }
}

Note : do not forget to inject the service in startup.cs

services.AddTransient<IStudentService, StudentService>();

using DemoHangfireNet5.Services;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.OpenApi.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using HangfireBasicAuthenticationFilter;
using DemoHangfireNet5.AppDbContext;
using Microsoft.EntityFrameworkCore;
using Hangfire;
using DemoHangfireNet5.Jobs;

namespace DemoHangfireNet5
{
    public class Startup
    {
        private static IStudentService IStudentService;
        private readonly Job jobscheduler = new Job(IStudentService);
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {

            services.AddControllers();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "DemoHangfireNet5", Version = "v1" });
            });




            #region Configure Connection String
            services.AddDbContext<StudentDbContext>(item => item.UseSqlServer(Configuration.GetConnectionString("myconnection")));
            #endregion

            #region Configure Hangfire
            services.AddHangfire(c => c.UseSqlServerStorage(Configuration.GetConnectionString("myconnection")));
            GlobalConfiguration.Configuration.UseSqlServerStorage(Configuration.GetConnectionString("myconnection")).WithJobExpirationTimeout(TimeSpan.FromDays(7));
            #endregion

            #region Services Injection
            services.AddTransient<IStudentService, StudentService>();
            #endregion

        }








        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                app.UseSwagger();
                app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "DemoHangfireNet5 v1"));
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

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

Secure the Hangfire Dashboard

To Secure the hangfire dashboard we setup login authentication in order to access the hangfire dashboard. I have hardcoded the username and password in the appsettings.js file to consume those in the startup.cs

"HangfireCredentials": {
"UserName": "adminadmin",
"Password": "admin@xxx#"
}

in startup.cs

app.UseHangfireDashboard("/hangfire", new DashboardOptions()  
{  
    AppPath = null,  
    DashboardTitle = "Hangfire Dashboard",  
    Authorization = new[]{  
    new HangfireCustomBasicAuthenticationFilter{  
        User = Configuration.GetSection("HangfireCredentials:UserName").Value,  
        Pass = Configuration.GetSection("HangfireCredentials:Password").Value  
    }  
},  
});

Hangfire Retention Time

Usually, the hangfire jobs running in the background will elapse for 24 hours.
To avoid this I have to enable the basic setting to last this job in the dashboard for at least 2 week.

Startup.cs

GlobalConfiguration.Configuration.UseSqlServerStorage(Configuration.GetConnectionString("myconn")).WithJobExpirationTimeout(TimeSpan.FromDays(14));

Persistence with SQL Database

Hangfire has an option to store all the job-related information in the database.
For this we don’t need anything we have to configure this setup in the Startup.cs and it automatically creates all the tables where we can see the job status and respective information in those tables.

services.AddHangfire(c => c.UseSqlServerStorage(Configuration.GetConnectionString("myconn")));

The above set of tables were created automatically when we configured the setup and point to the database.

There are 4 types of jobs that mostly we will use :

#region Job Scheduling Tasks  
// Recurring Job for every 5 min  
recurringJobManager.AddOrUpdate("Insert Employee : Runs Every 1 Min", () => jobscheduler.JobAsync(), "*/5 * * * *");  
  
//Fire and forget job   
var jobId =  backgroundJobClient.Enqueue(() => jobscheduler.JobAsync());  
  
//Continous Job  
backgroundJobClient.ContinueJobWith(jobId, () => jobscheduler.JobAsync());  
  
//Schedule Job / Delayed Job  
  
backgroundJobClient.Schedule(() => jobscheduler.JobAsync(), TimeSpan.FromDays(5));  
#endregion

– Recurring job – Every 5 minutes the background task runs and inserts data into database (you can use this website to understand the cron jobs  time : https://crontab.guru/#*/5)

– Fire and Forget – This job runs only once when we run the application.

– Continuous Job – When we want to run jobs one after another at that time this will be useful so that it will execute one by one.

– Schedule Job – If you want to schedule a task to run at a particular time.

Run the application

By default, the swagger endpoint will open. Now type hangfireDashboard as we defined in the URL by removing the swagger. It will ask for a username and password as we had already set up the authentication mechanism .

Link to project : https://bit.ly/3sSte6H

When you create a new .Netcore web API project ,you need to present and define in a very easy way to read .
In this case , Swagger is the solution .

Swagger is an Interface Description Language for describing RESTful APIs expressed using JSON. Swagger is used together with a set of open-source software tools to design, build, document, and use RESTful web services. Swagger includes automated documentation, code generation, and test-case generation.

Adding Swagger to a Web Api Core 3.1 project

You can add swagger to the project by installing the following NuGet package :

Swashbuckle.AspNetCore

Swagger Configuration

Sometimes configuring a nuget package can be hard and time wasting , but this not the case with swagger .

First we are going to  open Startup.cs and add Swagger service inside ConfigureServices

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

After that we are going to enable  Swagger in Configure() method :

app.UseSwagger();
         app.UseSwaggerUI(c => {

             c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");

         });

Now as I mentioned in the demo , we need to configure the launch browser in Debug from the properties of the solution :

Now, when we are going to start a new debugging session, we will be redirected to :

http://localhost:[yourportnumber]/swagger

Now , everything done if you are going to have one version of the API ,next we are going to see how to create different versions.

Versioning

When we update the API major version whenever we introduce breaking changes. Internally, we update minor and patch versions whenever we add functionality and backward-compatible updates. When we release a new major version of the an API clients can choose to either continue using an existing major version or migrate to the new one , so different versions must be present .

Changes that we need to do in Startup.cs :

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.OpenApi.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace swaggerytDemo
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();

            //Register the Swagger generator, defining 1 or more Swagger documents
            //services.AddSwaggerGen(c =>
            //{
            //    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
            //});

            services.AddControllers(options =>
            {
                options.Conventions.Add(new GroupingByNamespaceConvention());
            });

            services.AddSwaggerGen(config =>
            {
                var titlebase = "Ytdemo1";
                var desc = "Description";
                var termsofservice = new Uri("https://achrafbenalaya-ekgvbjdjgta4b4hz.francecentral-01.azurewebsites.net/");
                var license = new OpenApiLicense()
                {
                    Name = "MIT"
                };

                var contact = new OpenApiContact()
                {
                    Name = "achraf",
                    Email = "achrafbenalaya@gmail.com",
                    Url = new Uri("https://achrafbenalaya-ekgvbjdjgta4b4hz.francecentral-01.azurewebsites.net/")

                };


                config.SwaggerDoc("v1", new OpenApiInfo
                {
                    Version = "v1",
                    Title = titlebase + " V 1",
                    Description = desc,
                    Contact = contact,
                    License = license,
                    TermsOfService = termsofservice


                });

                config.SwaggerDoc("v2", new OpenApiInfo
                {
                    Version = "v2",
                    Title = titlebase + " V2",
                    Description = desc,
                    Contact = contact,
                    License = license,
                    TermsOfService = termsofservice


                });

            }

      );





        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }


            app.UseSwagger();
            app.UseSwaggerUI(c => {

                c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
                c.SwaggerEndpoint("/swagger/v2/swagger.json", "My API V2");

            });



            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

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

Now we need to add a convention to let swagger understand the different API version’s :

public class GroupingByNamespaceConvention : IControllerModelConvention
 {
     public void Apply(ControllerModel controller)
     {
         var controllerNamespace = controller.ControllerType.Namespace;
         var apiVersion = controllerNamespace.Split(".").Last().ToLower();
         if (!apiVersion.StartsWith("v")) { apiVersion = "v1"; }
         controller.ApiExplorer.GroupName = apiVersion;
     }
 }

Now we must apply the convention. For that we need to go to Startup.cs  ,look for ConfigureServices() and add the convention:

services.AddControllers(options =>
{
options.Conventions.Add(new GroupingByNamespaceConvention());
});

Project Link

Full Demos:

• 1-Insert this data to a table.
  2-Clean the data(empty rows removed ,rows missing data moved to another table).
  3-check for duplicated data in this table and delete them.
  4-check for duplicated data between this table and the original table and if there is duplication and move them to another ‘duplication table’.

Now , those steps are only for one received file ,if I have more I loose a lot of time .
So ,I said to my self  ,why not build a small application or website that do all this work for me .

The requirements for my application is to browse for an excel file, Upload the file , read each row from the excel file and insert into a table , when it finish inserting a stored procedure will run a sql query that I have created ,
and of course I will host the web application on azure app service .

So , I developed the web application and tested on my machine and then publish it to azure and at this time ,
I run into the “It works on my machine”

I mean I tested the app , the connection string everything was fine , I even hosted on my local IIS and it worked smoothly .
So I said it’s time to investigate so I went to my app service , looked for “Diagnose and solve problems” and than found out this error : ‘The Microsoft.ACE.OLEDB.12.0 provider is not registered on the local machine‘.

Well  , I’m using the OleDbDataAdapterto read the data from the excel file into the dataset.
And it seems that the Microsoft.ACE.OLEDB.12.0 Provider is only installed on my machine and can not be available on the azure app service .

So , I had to quickly find a new way to read my excel file without using the OleDbDataAdapter and that when I discovered a plugin : NPOI .

What is NPOI ?

NPOI is the .NET version of POI Java project at http://poi.apache.org/. POI is an open source project which can help you read/write xls, doc, ppt files. It has a wide application.

For example, you can use it to

• generate a Excel report without Microsoft Office suite installed on your server and more efficient than call Microsoft Excel ActiveX at background;
• extract text from Office documents to help you implement full-text indexing feature (most of time this feature is used to create search engines).
• extract images from Office documents
• generate Excel sheets that contains formulas .

You can install the package by running this command :

Install-Package DotNetCore.NPOI

Now , this is the way I was reading my excel file using the OleDbDataAdapter :


//get extension
string extension = Path.GetExtension(filename);           
string conString = string.Empty;
switch (extension)
{
   case ".xls": //Excel 97-03.
       conString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + filePath + ";Extended Properties='Excel 8.0;HDR=YES'";
       break;
   case ".xlsx": //Excel 07 and above.
       conString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + filePath + ";Extended Properties='Excel 8.0;HDR=YES'";
       break;
}

DataTable dt = new DataTable();
conString = string.Format(conString, filePath);

using (OleDbConnection connExcel = new OleDbConnection(conString))
{
   using (OleDbCommand cmdExcel = new OleDbCommand())
   {
       using (OleDbDataAdapter odaExcel = new OleDbDataAdapter())
       {
           cmdExcel.Connection = connExcel;
           connExcel.Open();
           DataTable dtExcelSchema;
           dtExcelSchema = connExcel.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);
           string sheetName = dtExcelSchema.Rows[0]["TABLE_NAME"].ToString();
           connExcel.Close();
           connExcel.Open();
           cmdExcel.CommandText = "SELECT * From [" + sheetName + "]";
           odaExcel.SelectCommand = cmdExcel;
           odaExcel.Fill(dt);
           var x = dt.Columns.AsParallel();
           connExcel.Close();
       }
   }
}

Now using the NPOI package we can do the same reading and clear out our problem and we don’t have to worry about it again .

     private static DataTable GetRequestsDataFromExcel(string fullFilePath)
     {
         try
         {
             var sh = GetFileStream(fullFilePath);
             var dtExcelTable = new DataTable();
             dtExcelTable.Rows.Clear();
             dtExcelTable.Columns.Clear();
             var headerRow = sh.GetRow(0);
             int colCount = headerRow.LastCellNum;
             for (var c = 0; c < colCount; c++)
                 dtExcelTable.Columns.Add(headerRow.GetCell(c).ToString());
             var i = 1;
             var currentRow = sh.GetRow(i);
             while (currentRow != null)
             {
                 var dr = dtExcelTable.NewRow();
                 for (var j = 0; j < currentRow.Cells.Count; j++)
                 {
                     var cell = currentRow.GetCell(j);

                     if (cell != null)
                         switch (cell.CellType)
                         {
                             case CellType.Numeric:
                                 dr[j] = DateUtil.IsCellDateFormatted(cell)
                                     ? cell.DateCellValue.ToString(CultureInfo.InvariantCulture)
                                     : cell.NumericCellValue.ToString(CultureInfo.InvariantCulture);
                                 break;
                             case CellType.String:
                                 dr[j] = cell.StringCellValue;
                                 break;
                             case CellType.Blank:
                                 dr[j] = string.Empty;
                                 break;
                         }
                 }
                 dtExcelTable.Rows.Add(dr);
                 i++;
                 currentRow = sh.GetRow(i);
             }
             return dtExcelTable;
         }
         catch (Exception e)
         {
             throw;
         }
     }


private static ISheet GetFileStream(string fullFilePath)
     {
         var fileExtension = Path.GetExtension(fullFilePath);
         string sheetName;
         ISheet sheet = null;
         switch (fileExtension)
         {
             case ".xlsx":
                 using (var fs = new FileStream(fullFilePath, FileMode.Open, FileAccess.Read))
                 {
                     var wb = new XSSFWorkbook(fs);
                     sheetName = wb.GetSheetAt(0).SheetName;
                     sheet = (XSSFSheet)wb.GetSheet(sheetName);
                 }
                 break;
             case ".xls":
                 using (var fs = new FileStream(fullFilePath, FileMode.Open, FileAccess.Read))
                 {
                     var wb = new HSSFWorkbook(fs);
                     sheetName = wb.GetSheetAt(0).SheetName;
                     sheet = (HSSFSheet)wb.GetSheet(sheetName);
                 }
                 break;
         }
         return sheet;
     }

After this , I republished the project and everything worked fine .

well hope this was helpful ,time to get some food .
have a good day

I usually see my friends postpone upgrading their projects to a newer version because of some factors like : the complexity ,the effort and the cost ,so they end up not migrating to a new version and loose the improvements and postpone that to another time and they forget that the more the project is complex , the more the migration becomes complex .

You can upgrade your system by updating visual studio 2019 to the latest version (the update will install the new .NET 5.0 but if you want to install it by your self you can do it from this Link)

Upgrading a net core project :

simply to to do the migration you have to go to properties and change the target framework to .NET 5.0 .
Well , of course now you need to build the project and if everything is fine you will see succeeded ,

else you will have to investigate issue by issue ,for that do not forget to upgrade the packages used by your application to the newest possible version .

I think that was easy , now what if you want to publish this project to azure ?

Publish .NET 5.0 to Azure

With the announcement of the new version of .NET 5.0 , Microsoft have added a new option to publish the new update in app service .
If you go and create a new app service (Create Web App) you will see under the Runtime stack a new option was added : .NET 5 (Early access) ;

all you have to do is to create the app download the profile and publish your solution .

If you have any question feel free to contact me .

Thank you for reading my article !

It is not enough to log errors in order to use them for troubleshooting purposes. It is also useful to log successful requests so we can have a clear idea of how users work with the application .

Logs are also useful to detect  mistakes that users make, as well as for security purposes. Writing good logs about a user’s activity can alert us about malicious activity or any other kind of problems that we didn’t detect .

Why use Serilog ?

Serilog provides basic diagnostic logging not only to the console, files, Amazon, Azure, but more ,it’s easy to integrate and to use in a few steps .

This article will demonstrate the console and file sinks. It is easy as 1, 2, 3 to set up with appsettings configurations.

Steps : 

First thing that we are going to do is to create a new empty solution (Web Api )

Now we need to use the package manager to install some extensions as in pictures below or you can use the command :

Serilog.AspNetCore package

Logger initialization in Program.cs :

To start working with Serielog we need to initilize it first in the program.cs  .
You can copy replace your code with the below code :

public static void Main(string[] args)
       {
           var configuration = new ConfigurationBuilder()
           .AddJsonFile("appsettings.json")
           .Build();

           Log.Logger = new LoggerConfiguration()
               .ReadFrom.Configuration(configuration).WriteTo.Console().CreateLogger();

           try
           {
               Log.Information("Application startinng up");
               CreateHostBuilder(args).Build().Run();
           }
           catch (Exception ex)
           {

               Log.Fatal(ex, "The application failed to start correctly");
           }
           finally
           {
               Log.CloseAndFlush();

           }



       }

Also , we need to add : .UseSerilog() inside the CreateHostBuilder :

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

Next , inside the Startup.cs we need to add : app.UseSerilogRequestLogging();

Now if we run our solution , we should see inside the console a message saying : Application startinng up ,

if you remember we added a line of code that will fire when the application start :

Log.Information("Application startinng up");

Cleaning up The default logger :

There are a few more changes that we are going to do and now inside the appsettings.json .

Serilog completely replaces the logging implementation on .NET Core,it will not work together  but it will replace the default implementation . The benefit of this is that you’re not running two different logging frameworks with tricky edge cases where they overlap in functionality.

{
  "AllowedHosts": "*",
  "Serilog": {
    "Using": [],
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft": "Warning",
        "System": "Warning"
      }
    },
    "Enrich": [ "FromLogContext", "WithMachineName", "WithProcessId", "WithThreadId" ],
    "WriteTo": [
      { "Name": "Console" },
      {
        "Name": "File",
        "Args": {
          "path": "Logs/log.txt",
          "rollingInterval": "Day",
          "outputTemplate": "{Timestamp:G} {Message}{NewLine:1}{Exception:1}"
        }
      },
      {
        "Name": "File",
        "Args": {
          "path": "Logs/log.json",
          "rollingInterval": "Day",
          "formatter": "Serilog.Formatting.Json.JsonFormatter, Serilog"
        }
      }
   
    ]
  }
}

The “Name” key here specifies the sink desired. To write to multiple sinks, add another object to the “WriteTo” array , in our case we want to create files inside a logs folder and each day we want to create a new different file that contain the date time .

The MinimumLevel configuration object provides for one of the log event levels to be specified as the minimum.

If you see ,we have “path“: “Logs/log.txt”, where we define where we want our file to be written to and stored .

rollingInterval here mean that we want to create a new file per day .

as you can see inside write to , we defined to object , one that will write to a text file and another one that’s going to write inside a json file .

Now let’s run our solution :

As you can see there is a new Folder created : Logs , that contain a json file and a txt file .
let explore those 2 files :

{"Timestamp":"2020-09-13T15:04:23.3942682+01:00","Level":"Information","MessageTemplate":"Application startinng up"}
{"Timestamp":"2020-09-13T15:04:25.9319025+01:00","Level":"Information","MessageTemplate":"Getting WeatherForecast details","Properties":{"ActionId":"9612d1c8-4c4e-44b7-b7fd-374fe905687c","ActionName":"SerielogDemoDay.Controllers.WeatherForecastController.Get (SerielogDemoDay)","RequestId":"0HM2NTNM09MCA:00000001","RequestPath":"/weatherforecast","SpanId":"|b35b87a8-42a0adeaed09085c.","TraceId":"b35b87a8-42a0adeaed09085c","ParentId":""}}
{"Timestamp":"2020-09-13T15:04:25.9642904+01:00","Level":"Information","MessageTemplate":"HTTP {RequestMethod} {RequestPath} responded {StatusCode} in {Elapsed:0.0000} ms","Properties":{"RequestMethod":"GET","RequestPath":"/weatherforecast","StatusCode":200,"Elapsed":134.7792,"SourceContext":"Serilog.AspNetCore.RequestLoggingMiddleware","RequestId":"0HM2NTNM09MCA:00000001","SpanId":"|b35b87a8-42a0adeaed09085c.","TraceId":"b35b87a8-42a0adeaed09085c","ParentId":""},"Renderings":{"Elapsed":[{"Format":"0.0000","Rendering":"134.7792"}]}}

As You can see the json file is very detailed file that contain all the event that happened .

while the txt file below , contain the actions with date time .

09/13/2020 15:04:23 Application startinng up
09/13/2020 15:04:25 Getting WeatherForecast details
09/13/2020 15:04:25 HTTP "GET" "/weatherforecast" responded 200 in 134.7792 ms

and now you can log anywhere inside your application by just using :

Log.Debug("debug test!");
Log.Information("Informations here.....!");
Log.Error("Error here ....!");

Link to demo project .

Well , I stood like that for 5 minutes and ended up saying that I don’t know the answer , then the interviewer get up from his desk and explained it to me by writing on a blackboard . When he was explaining I was saying in my mind : ‘Dude ,I have been doing that all my life , I didn’t know it’s called boxing and unboxing ! ‘ .

Well , that was an interview that didn’t go well , but at least I learned something from it which encouraged me to write about it now .

What is Boxing And Unboxing ? Boxing is the process of converting a value type to the type object or to any interface type implemented by this value type.

So when we say boxing,we say it’s the process of taking a value type ,putting it inside a new object on the heap and storing a reference to it on the stack . Unboxing is the exact opposite.

The difference between a value type and a reference type is that the value type stores its value directly,a reference type stores a reference that points to an object on the heap that contains the value. so : Unboxing extracts the value type from the object. Boxing is implicit and unboxing is explicit.

Let’s start by a simple boxing example :

int i = 123456;

// The following line boxes i inside object o. object o = i; The object o now, can be unboxed and assigned to integer variable i

o = 123; i = (int)o;

// unboxing o Let’s see one more example , so we have the following code :

class TestUnboxing

class TestUnboxing 
{ static void Main() { int i = 123; object o = i; // implicit boxing

    try
    {
        int j = (short)o;  // attempt to unbox

        System.Console.WriteLine("Unboxing OK.");
    }
    catch (System.InvalidCastException e)
    {
        System.Console.WriteLine("{0} Error: Incorrect unboxing.", e.Message);
    }
}
}

So the output of this code if you try to execute it is , ” Specified cast is not valid. Error: Incorrect unboxing. ” and why is that ?

As you can see , we have defined i as int , but when we tried to unbox it we used short which cause the exception here , so what we need to do is :

int j = (int) o;
A picture that can explain all that :

Performance In relation to simple assignments, boxing and unboxing are computationally expensive processes. When a value type is boxed, a new object must be allocated and constructed. To a lesser degree, the cast required for unboxing is also expensive computationally. For more information, see Performance in Microsoft official website .

Happy boxing && unboxing day