One of the essential elements in any technological system is its ability to pick and understand the most effective .Net Libraries that enable improving the development process. The rapid growth of the online marketplace is in line with the rise of the digital population.There appears to be lots of activity and the amount of competition between companies and developers is increasing.

One such technology that helps in providing services that are friendly for customers and users includes that of the .NET framework. Microsoft’s. NET Core Framework has been an incredible success. It enables .NET developers to build strong high-quality, efficient, and feature-rich websites on the go, and .NET applications.

While the .NET development business is growing quickly, it is creating more libraries to satisfy the diverse needs of developers. So, listed below are the top most important .NET libraries that .Net developers use when developing .NET apps. They will assist in your choice and comprehension of the various class libraries that are portable and considered essential to .NET Core integration.

Benefits of AutoMapper

AutoMapper

When developers employ AutoMapper for mapping the properties of two different types of objects they have proven its ability as an object-to object mapper library. AutoMapper makes it easy to set up types for mapping and testing. Methods for mapping objects perform the conversion from one type of object to another. AutoMapper offers attractive standards to help you avoid the hassle with manually converting one kind to another. Since issues in one layer are often in conflict with issues in the other object-object mapping produces partitioned models where issues in a specific layer only affect specific types at this level.

Let’s See How to Use AutoMapper Library

Step 1: Here are the Employee entity and Employee view model classes.

 
                        public class Employee
                        {
                        public Guid Id { get; set; } = Guid.NewGuid();
                        public string Name { get; set; }
                        public string Email get; set; }
                        public DateTime CreatedDate { get; set; } = DateTime.Now;
                    
                        
                        

                        
                            public class EmployeeViewModel
                        {
                        [Required]
                        public string Name { get; set; }
                        [Required]
                        public string Email { get; set; }
                        }
                        
                        

Step 2: In order to implement AutoMapper, first we should download a NuGet Packages to our project:

Step 3: Create a mapping profile that specifies how to map the properties between the Employee entity and the EmployeeViewModel.

                        
                            public class MappingProfile: Profile
                            {
                            public MappingProfile()
                            {
                            CreateMap()
                            .ForMember(dest=> dest.Name, opt=> opt.MapFrom(src => src.Name))
                            .ForMember(dest=> dest.Email, opt=> opt.MapFrom(src => src.Email));
                            }
                            }
                        
                    

Step 4: After creating the proper mapping profile class, the next step is to register AutoMapper as a Service in the Program.cs file.

                                // Add services to the container,
                                builder.Services.AddA flapper(typeof(Program).Assembly);
                                builder.Services.AddControllersWithViews();
                                vår app = builder.Build();
                                

Step 5: We can map Employee entities with EmployeeViewModel in the controller methods.

                        
                        using AutoMapper:
using Microsoft.AspNetCore.Mvc;
using PracticeAPP.Models;
using PracticeAPP.Models.Entities;
using PracticeAPP.Models.ViewModels;
using System.Diagnostics;
namespace PracticeAPP.Controllers
                    
public class HomeController: Controller
{
private readonly ILoggerloggerlogger;
private readonly IMapper_mapper;
public HomeController(ILoggerlogger, IMapper mapper)
{
_logger= logger;
_паppег= mapper;
}
public IActionResult Index()
{
return View();
}
public IActionResult Register(EmployeeViewModel model)
if (!ModelState.IsValid)
return BadRequest(ModelState);
var employee= _mapper.Map(model);
return View(employee);
}

                    

Polly

Polly is an .NET library that addresses temporary faults and retries. It also offers programmers a clear and safe approach to define rules such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback.

In addition, with only two lines of code Polly will protect resources and stop the making of queries to services that are not working or retrying unsuccessful requests. prior cache results, stop long-running queries, and, in the worst case scenario offer a default response. Polly is also thread-safe, and works with both Asynchronous and synchronous calls.

Polly allows users of the .NET ecosystem to utilize try..catch and when integrated into an environment that is distributed it could assist in calling various processes, databases and other.

Let’s See How to Use Polly Library

Polly is a .NET resilience strategy and a transient fault management library that allows developers to define resilience-related policies, such as Retry policy and circuit Breakers, Timeout, Bulkhead Isolation policy, and Fallback. Polly is targeted at ASP.NET Core, which makes it a crucial tool to help with. NET Core resilience.

Swashbuckle

Utilize the .NET library to produce polished API documentation. It is possible to make use of Swagger’s Swagger UI to examine and play around with API actions within Swashbuckle too. Its main function is to create a Swagger specification file to be used in the .Net-based project. This program is a full set of tools that can be used to create .NET APIs. It might surprise you to know that we used C# instead of JavaScript to create this.

Let’s See How to Use Swashbuckle Library

Step 1: Install the Swashbuckle.AspNetCore.

                            

                          //Add AddSwaggerGen
                                builder.Services.AddSwaggerGen(); 
                                builder.Services.AddControllersWithViews();
                                vår app = builder.Build();
                                 
                                //Configure the HTTP request pipeline.
                                 
                                if (!app.Environment.IsDevelopment())
                                {
                                app.UseExceptionHandler("/Home/Error");
                                }
                                //Config Swagger for Dev
                                if (app.Environment.IsDevelopment())
                                {
                                app.UseSwagger();
                                app.UseSwaggerUI();
                                }
                            
                                

CacheManger

• To help the cache providers that are part of .NET features that are enhanced for implementation, CacheManager was built as an open-source .NET Network library for C#. C# programming language.
• By using CacheManager, the .NET CacheManager library, developers can streamline their work and deal with even the most complex cache scenarios with just two pages of code.

Let’s See How to Use CacheManger Library

                            
    services.AddLogging (c => c.AddConsole() .AddDebug().AddConfiguration (Configuration));
    services .AddCacheManager Configuration (Configuration,cfg=> cfg.WithMicrosoftLogging (services));
    services .AddCacheManager  (Configuration, configure: builder => builder. WithJsonSerializer());
    services .AddCacheManager  (inline => inline. WithDictionary Handle());
    services .AddCacheManager();
                            
    
    
                        

Step 2: Now, We will use CacheManager in Values Controller.

                        

                     
[Route("api/[controller]")]
public class ValuesController: Controller
{
private readonly ICacheManager _cache;
public ValuesController(ICacheManager valuesCache, ICacheManager intCache, ICacheManager dates)
{
_cache = valuesCache;
dates.Add("now", DateTime.UtcNow); 
intCache.Add("count", "1");
}
// DELETE api/values/key
[HttpDelete("{key}")]
public IActionResult Delete(string key)
{
if (_cache.Remove(key))
{
return Ok();
}
return NotFound();
}
 
// GET api/values/key 
[HttpGet("{key}")]
public IActionResult Get(string key)
{ 
var value = _cache.GetCacheItem(key);
if (value == null)
{ 
return NotFound();
}
return Json(value.Value);
}

// POST api/values/key
[HttpPost( “{key}")] 
Public IActionResult Post(string key, [FromBody]string value)
{
if (_cache.Add(key, value))
{
return Ok();
}
return BadRequest("Item already exists.");
}
// PUT api/values/key
[HttpPut("{key}")]
public IActionResult Put(string key, [FromBody]string value)
{
if (_cache. AddOrUpdate(key, value, (v) => value) != null)
{
return Ok();
}
return NotFound();
}
}


                    

Dapper

To ease communication between applications and databases You could make use of Dapper which is an Object-Relational Modeler (ORM) that can be described more specifically. Micro ORM that works with SQL server. Dapper lets you write SQL statements using the same format as SQL Server. Dapper’s speed is unbeatable since it doesn’t modify SQL queries made within .NET. Dapper is able to execute procedures either in synchronous or asynchronous fashion.

Benefits of Dapper

Size : It’s light, and simple to operate and access.

Security : Dapper is not affected by SQL Injection so that you can run parameterized queries without restriction. The assistance offered by several databases is a further important aspect.

Database Compatibility : Dapper can be used with a wide array of database services. Dapper is an extension of ADO.NET’s IDbConnection that adds convenient methods to interact using your database.

Let’s See How to Use Dapper Library

                            

                          
public class Employee
{
public Guid Id { get; set; } Guid. NewGuid();
public string Name { get; set; }
public string Email { get; set; }
public DateTline CreatedDate { get; set; } = DateTime.Now;
}
 
public class Company
{
public int Id { get; set; }
public string Name { get; set; }
public string Address { get; set; }
public string Country { get; set; }
public List Employees { get; set; } = new List();
}

                        

                            

                           
public class DapperContext
{
private readonly IConfiguration _configuration;
private readonly string _connectionString;
public DapperContext(IConfiguration configuration)
{
_configuration = configuration;
_connectionString =_ configuration.GetConnectionString("SqlConnection");
}
public IDbConnection CreateConnection()
=> new SqlConnection(_connectionString);
}

                        

                            

                          
builder.Services.AddSingleton();
builder.Services.Add Controllers

                        

                            

                           
public interface ICompanyRepository
{
public Task> GetCompanies();
}
using Dapper;
using PracticeAPP.Context;
using PracticeAPP.Contracts;
using PracticeAPP.Models.Entities;
 
namespace PracticeAPP.Repository
{
public class CompanyRepository: ICompanyRepository
{
private readonly DapperContext _context;
 
public CompanyRepository(DapperContext context)
{
_context = context;
}
public async Task> GetCompanies()
{
var query= "SELECT * FROM Companies";
using (var connection = _context.CreateConnection())
{
var companies = await connection.QueryAsync(query);
return companies. Tolist();
   }
  }
 }
}


                            

Ocelot

Ocelot can be described as an asp.net core library that acts as an API bridge to .NET APIs. It is targeted at a group of .NET developers that require an interface for their decentralized services as well as microservice functionality. However, it can work on any platform where ASP.NET Core is accessible and can be used with any application that can understand HTTP.

It tricked its HTTP Request object into a state it is able to determine by its parameters, until it is transformed through a middleware for request building. A HTTP request message is created from there, and then used to connect with an online service. The Ocelot pipeline is completed with the sending of the request to middleware. Following that the middleware ceases to make calls. middleware will be made. When requests are made upstream along the Ocelot pipe, they will be followed by an answer by the service downstream.

This is how the Ocelot API Gateway Works in our project.

Let’s See How to Use Ocelot Library

                            

                           
public void ConfigureServices(IServiceCollection services)
{
Action settings = (x) =>
{
x.WithMicrosoftLogging(log =>
{
log.AddConsole(LogLevel.Debug);
}).WithDictionaryHandle();
}; services.AddOcelot(Configuration, settings);
}
public async void Configure(IApplicationBuilder app, IHostingEnvironment env )
{
await app.UseOcelot();


}

                            

Run the projects.

Now make sure that you’ve made all projects as startup projects. To do this, follow these steps:

1. In the Solution Explorer window, right-click on the solution file.

2. Click “Properties”.

3. In the “Property Pages” window, select the “Multiple startup projects” radio button

4. Click Ok.

Autofac

To support .NET programs, Autofac provides an IoC container. It allows programs to be flexible when they grow in terms of size and complexity, by regulating inter-class relations. To accomplish this aim, developers can utilize standard .NET classes as elements.

Let’s See How to Use Autofac Library

Step 1: Install Autofac and Autofac.Extensions.DependencyInjection nuget package

Step 2: The code in program class will change to use Autofac as the DI container.

builder.Host. UseServiceProviderFactory (new AutofacService ProviderFactory());

                            

                            
using PracticeAPP.Contracts;
namespace PracticeAPP.Repository
{
public class AutofacRepository: IAutofacRepository
{
public string getStringAutofac()
{
return "Hello Autofac Data";
  }
 }
}
 
namespace PracticeAPP.Contracts
{
public interface IN Autofac Repository
{
   public string getStringAutofac();
 }
}

                        

                            

                           
using Microsoft.AspNetCore.Mvc;
using PracticeAPP.Contracts;
namespace PracticeAPP.Controllers
{
public class AutofacController: Controller
{
private readonly IN Autofac Repository _autofacRepository;
public AutofacController(IAutofacRepository autofacRepository)
{
this._autofacRepository=autofacRepository;
}
// GET api/values
[HttpGet]
public string GetStringAutofac()
{
return _autofacRepository.getStringAutofac();
  }
 }
}

                            

MediatR

A person who describes the dynamic between several parties is described as the mediator pattern within the area of development software. This pattern is categorized as a behavioral one because it is able to modify the behavior of the program while it is in use.

MadiateR is a basic application of the mediator within .NET. Request/response, instruction, questions as well as notifications and instances. In this library, both the synchronous and asynchronous functions are enabled by the clever distribution and dispatching C# generic variance.

MediatR could be viewed to be an “in-progress” version of Mediator that allows the creation of CQRS systems. In the plethora of useful .Net libraries, MediatR stands out.

Let’s See How to Use Autofac Library

Step1: Create a new web API project.

Step 2: Create a folder with these three classes.

Step 3: ApiRequestModel: This class represents a request for API.

                        

                        
using MediatR;
namespace MediatrApiProject.APIFolder
{
public class ApiRequestModel: IRequest
{
public int Number { get; set; }
}
}
— IRequest<> It represents a request with a response.

                    

Step 4: ApiResponseModel: This class represents a response of API.

                        

                        
namespace MediatrApiProject.APIFolder
{
public class ApiResponseModel
{
public string Response { get; set; } = string.Empty;
}
}

                    

Step 5: ApiHandler: And this class keeps the Media R

                        

                     
using MediatR;
namespace MediatrApiProject.APIFolder
{
public class ApiHandler: IRequestHandler
public async Task Handle(ApiRequestModel apiRequest, CancellationToken cancellationToken)
{
var response = $"Number :- {apiRequest.Number}";
return new ApiResponseModel
{
Response=response
};
}
}


                    

Step 6: ApiHandler: MediaR

                        

                        
using MediatR;
using Microsoft.AspNetCore.Mvc;
namespace MediatrApiProject.Controllers

[ApiController]
[Route("api/[controller]")]
public class APIControllerBase : ControllerBase
{
private ISender _mediator;
protected ISender Mediator => mediator ??= HttpContext. RequestServices.GetService();
 }

                    

Step 7: ApiHandler: And this class for MediaAPIFolder

                        

                        
                        using MediatrApiProject.APIFolder;
using Microsoft.AspNetCore.Mvc;
namespace MediatrApiProject.Controllers
{
public class HomeController: APIControllerBase
{
public HomeController() { }
[HttpGet(nameof(ApiController))]
public async Task> ApiController(int number)
{
    try
    {
       var request = new ApiRequestModel { Number = number };
       return await Mediator.Send(request);
    }
    catch (Exception ex)
    {
         throw;
    }
   }
  }
}

                    

Step 8 : Test this API using swagger.

Fluent Validation

Fluent Validation is an .NET Framework class library used to build validation rules that can be highly constructed. Fluent Validation can be a fantastic alternative to annotations of data for validation of models. It allows for a greater separation of problems as well as a better control of validation rules and makes them simple to understand and test. The Lambda expression is used to verify the authenticity of. When you require complex validation for users’ data Fluent Validation is a great tool.

Let’s See How to Use Fluent Validation Library

                            

                           
public class Employee
{
public Guid Id {get; set; }= Guid.NewGuid();
public string Name { get; set; }
public string Email { get; set; }
public DateTime CreatedDate { get; set; } DateTime.Now;
}

                        

                            

                            
                            public class EmployeeDtoValidator: AbstractValidator
                                {
                                public EmployeeDtoValidator()
                                {
                                RuleSet("name", () =>
                                {
                                RuleFor(x => x.Name). NotNull().WithMessage("name could not be null");
                                });
                                RuleSet("email", () =>
                                {
                                RuleFor(x => x.Email).NotNull().WithMessage("email could not be null");
                                });
                                }
                                }
                             
                        

                            builder.Services.AddScoped, EmployeeDtoValidator>();
                                builder.Services.AddValidatorsFromAssemblyContaining();
                                
                        

                            

                            
For example, you might have a controller that looks like this


public class EmployeeController: Controller
{
private IValidator _validator;
public EmployeeController(IValidator validator)
{
//Inject our validator and also a DB context for storing our Employee object.
 
   _validator = validator;
 
}
public ActionResult Create()
{
return View();
}
 
[HttpPost]
public async Task Create(Employee employee)
{
var result= await _validator.ValidateAsync(employee);
if (!result.IsValid)
{
//re-render the view when validation fails. 
 
return View("Create", employee);
}
TempData["notice"] = "Employee successfully created";
 return RedirectToAction("Index");
    }
  }


                            

SignalR

One of the main goals of modern application development is to provide users real-time information. If you’re developing an application, game or any other type of application that you’re developing, you could benefit from real-time functions. The capability of your server-side software to quickly transmit information to other clients is a sign of real-time capabilities. In this instance we will require SignalR within .Net Core. It also simplifies the process dramatically. Similar to a chatroom, SignalR automates the management of connections and lets you send messages to everyone simultaneously.

You can incorporate SignalR hubs written in C# in the .NET Core project along with your APIs and pages. Additionally, the basic approach to programming naturally integrates other advanced features in NET such as dependency injection and authorization, authentication and the ability to extend.

SignalR is an open source library that allows you to create real-time web applications within ASP.NET Core. SignalR has an API that enables server-side software to transmit messages to browsers on the client.

Benefits of SignalR:

Let’s See How to Use SignalR Library

                            

                            builder.Services.AddSignalR();
                            builder.Services.AddCors options => {
                            options.AddPolicy ("CORSPolicy", builder=> 
                            builder .AllowAnyMethod() .AllowAnyHeader() .AllowCredentials() .SetIsOriginAllowed ((hosts) => true));
                            };
                        
                            

                            

                            
public interface IMessageHubClient
{
Task SendOffersToUser(List message);
}

Implement MessageHubClient class: Develop the actual SignalR hub that extends the IMessageHubClient interface. This class manages to send offers to clients.


public class MessageHubClient: Hub
{
public async Task SendOffersToUser(List message)
{
await Clients.All.SendOffersToUser(message);
}
}

                            

                            

                            
public class OfferController: Controller
{
private IHubContext messageHub;
public OfferController(IHubContext_messageHub)
{
messageHub = messageHub;
}
[HttpPost]
[Route("electronic offers")]
public string Get()
{
List offers = new List();
offers.Add("28% Off on IPhone 12");
offers.Add("15% Off on HP Pavilion");
offers.Add("25% Off on Samsung Smart TV");
messageHub.Clients.All.SendOffersToUser(offers);
return "Offers sent successfully to all users!";
}
}

                            

MailKit

MailKit is among the most popular Net Standard libraries. It is the top of MimeKit which is a .net main library that powers email clients that are cross-platform. The aim of this project is to provide robust, rich, feature-packed, and fully compatible RFC SMTP, POP3, and IMAP client network implementations.

Benefits of MailKit

Security : Simple Authentication and Security Layer (SASL) Authentication.

Proxy Support:Proxy support for SOCKS4/4a, SOCKS, and HTTP.