Manejo De Excepciones Globales En Aplicaciones ASP.NET Core

En este artículo, aprenderemos sobre el manejo global de excepciones en las aplicaciones ASP.NET Core. Las excepciones son algo inevitable en cualquier aplicación por muy bien que esté el código base. Esto generalmente también puede ocurrir debido a factores externos, como problemas de red, etc. Si estas excepciones no se manejan bien dentro de la aplicación, es posible que toda la aplicación termine y se pierdan datos.

El código fuente para la implementación se puede encontrar aquí .

Primeros pasos con el manejo de excepciones en ASP.NET Core

Para esta demostración, trabajaremos en un nuevo proyecto de API web de ASP.NET Core. Usaré Visual Studio 2019 como mi IDE predeterminado.

El bloque try-catch es nuestro enfoque principal cuando se trata de un manejo rápido de excepciones. Veamos un fragmento de código que demuestra lo mismo.

[HttpGet]
public IActionResult Get()
{
try
{
var data = GetData(); //Assume you get some data here which is also likely to throw an exception in certain cases.
return Ok(data);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return StatusCode(500);
}
}

Aquí hay una implementación básica a la que todos estamos acostumbrados, ¿sí? Supongamos que el método GetData() es una llamada de servicio que también es propensa a excepciones debido a ciertos factores externos. La excepción lanzada es capturada por el bloque catch cuya responsabilidad es registrar el error en la consola y devuelve un código de estado de 500 Error interno del servidor en este escenario.

Para obtener más información sobre el inicio de sesión en las aplicaciones ASP.NET Core, le recomiendo que consulte los siguientes artículos que demuestran cómo iniciar sesión con probablemente los 2 mejores marcos de inicio de sesión para ASP.NET Core: Serilog y NLog.

Digamos que hubo una excepción durante la ejecución del método Get(). El siguiente código es la excepción que se activa.

lanzar una nueva excepción ( "Ocurrió un error..." ) ;

Esto es lo que verías en Swagger.

La consola puede brindarle un poco más de detalles sobre la excepción, como el número de línea y otros registros de rastreo.

Aunque esta es una forma sencilla de manejar las excepciones, también puede aumentar las líneas de código de nuestra aplicación. Sí, podría tener este enfoque para aplicaciones muy simples y pequeñas. Imagine tener que escribir el bloque try-catch en todas y cada una de las acciones del controlador y otros métodos de servicio. Bastante repetitivo y no factible, ¿sí?

Sería ideal si hubiera una manera de manejar todas las excepciones de forma centralizada en una ubicación, ¿verdad? En las siguientes secciones, veremos 2 enfoques de este tipo que pueden mejorar drásticamente nuestro mecanismo de manejo de excepciones al aislar todas las lógicas de manejo en una sola área. Esto no solo brinda una mejor base de código, sino también una aplicación más controlada con problemas de manejo de excepciones aún menores.

Middleware de manejo de excepciones predeterminado en ASP.NET Core

Para facilitar las cosas, UseExceptionHandler Middleware viene listo para usar con las aplicaciones ASP.NET Core. Esto, cuando se configura en el método Configure de la clase de inicio, agrega un middleware a la canalización de la aplicación que detectará cualquier excepción dentro y fuera de la aplicación. Así es como funcionan los Middlewares y los pipelines, ¿sí?

Veamos cómo se implementa UseExceptionHandler. Abra el método Configure en la clase Startup de su aplicación ASP.NET Core y configure lo siguiente.

app.UseExceptionHandler(
options =>
{
options.Run(async context =>
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
context.Response.ContentType = "text/html";
var exceptionObject = context.Features.Get<IExceptionHandlerFeature>();
if (null != exceptionObject)
{
var errorMessage = $"{exceptionObject.Error.Message}";
await context.Response.WriteAsync(errorMessage).ConfigureAwait(false);
}});
}
);

Esta es una configuración y uso muy básicos de UseExceptionHandler Middleware. Por lo tanto, cada vez que se detecta una excepción dentro de la canalización de la aplicación, el control recurre a este middleware, que a cambio enviará una respuesta personalizada al remitente de la solicitud.

En este caso, se envía un código de estado de 400 Solicitud incorrecta junto con el contenido del mensaje de la excepción original que, en nuestro escenario, es "Se produjo un error...". Bastante sencillo, ¿sí? Así es como se muestra la excepción en Swagger.

Ahora, cada vez que se lanza una excepción en cualquier parte de la aplicación, este middleware la detecta y devuelve la excepción requerida al consumidor. Mucho código limpio, ¿sí? Pero aún hay más formas de mejorar esto, por millas.

Middleware personalizado: manejo global de excepciones en ASP.NET Core

En esta sección, vamos a crear un Middleware de manejo de excepciones global personalizado que le da aún más control al desarrollador y hace que todo el proceso sea mucho mejor.

Middleware de manejo de excepciones globales personalizado: en primer lugar, ¿qué es? Es un fragmento de código que se puede configurar como un middleware en la canalización de ASP.NET Core que contiene nuestras lógicas de manejo de errores personalizadas. Hay una variedad de excepciones que pueden ser capturadas por esta canalización.

También crearemos clases de excepciones personalizadas que esencialmente pueden hacer que su aplicación genere excepciones más sensibles que se puedan entender fácilmente.

Pero antes de eso, construyamos una clase de Respuesta que recomiendo que sea parte de cada proyecto que construyas, al menos el concepto. Por lo tanto, la idea es hacer que su ASP.NET Core API envíe respuestas uniformes sin importar el tipo de solicitudes que reciba. Esto hace que el trabajo sea más fácil para quien esté consumiendo tu API. Además, brinda mucha experiencia durante el desarrollo.

Cree una nueva clase ApiResponse y copie lo siguiente.

public class ApiResponse<T>
{
public T Data { get; set; }
public bool Succeeded { get; set; }
public string Message { get; set; }
public static ApiResponse<T> Fail(string errorMessage)
{
return new ApiResponse<T> { Succeeded = false, Message = errorMessage };
}
public static ApiResponse<T> Success(T data)
{
return new ApiResponse<T> { Succeeded = true, Data = data };
}
}

La clase ApiResponse es de tipo genérico, lo que significa que se puede pasar cualquier tipo de datos junto con ella. La propiedad de datos contendrá los datos reales devueltos por el servidor. El mensaje contiene cualquier excepción o mensaje de información en tipo de cadena. Y finalmente hay un booleano que indica si la solicitud es exitosa. También puede agregar muchas otras propiedades según sus requisitos.

También tenemos un método de falla y éxito que está diseñado específicamente para nuestro escenario de manejo de excepciones. Puede encontrar cómo se utiliza esto en las próximas secciones.

Como se mencionó anteriormente, también vamos a crear una excepción personalizada. Cree una nueva clase y asígnele el nombre SomeException.cs o cualquier cosa. Asegúrese de heredar Exception como clase base. Así es como se ve la excepción personalizada.

public class SomeException : Exception
{
public SomeException() : base()
{
}
public SomeException(string message) : base(message)
{
}
public SomeException(string message, params object[] args) : base(String.Format(CultureInfo.CurrentCulture, message, args))
{
}
}

Así es como usaría esta clase de excepción personalizada que creamos ahora.

throw new SomeException("An error occurred...");

Hazte una idea, ¿verdad? De esta manera, puede diferenciar realmente entre excepciones. Para obtener aún más claridad en relación con este escenario, supongamos que tenemos otras excepciones personalizadas como ProductNotFoundException, StockExpiredException, CustomerInvalidException, etc. Solo dé algunos nombres significativos para que pueda identificarlos fácilmente. Ahora puede usar estas clases de excepción dondequiera que surja la excepción específica. Esto envía la excepción relacionada al middleware, que tiene lógica para manejarla.

Ahora, vamos a crear el Middleware de Manejo de Excepciones Globales. Cree una nueva clase y asígnele el nombre ErrorHandlerMiddleware.cs

public class ErrorHandlerMiddleware
{
private readonly RequestDelegate _next;
public ErrorHandlerMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task Invoke(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception error)
{
var response = context.Response;
response.ContentType = "application/json";
var responseModel = ApiResponse<string>.Fail(error.Message);
switch (error)
{
case SomeException e:
// custom application error
response.StatusCode = (int)HttpStatusCode.BadRequest;
break;
case KeyNotFoundException e:
// not found error
response.StatusCode = (int)HttpStatusCode.NotFound;
break;
default:
// unhandled error
response.StatusCode = (int)HttpStatusCode.InternalServerError;
break;
}
var result = JsonSerializer.Serialize(responseModel);
await response.WriteAsync(result);
}
}
}

Línea 3: RequestDelegate denota una finalización de solicitud HTTP.
Línea 10: un bloque simple de intento y captura sobre el delegado de solicitud. Significa que cada vez que hay una excepción de cualquier tipo en la tubería para la solicitud actual, el control pasa al bloque catch. En este middleware, el bloque Catch tiene todas las bondades.

Línea 14: captura todas las excepciones. Recuerde, todas nuestras excepciones personalizadas se derivan de la clase base Exception.
Línea 18: crea un modelo de respuesta API a partir del mensaje de error mediante el método Fail que creamos anteriormente.
Línea 21: en caso de que la excepción detectada sea del tipo SomeException, el código de estado se establece en BadRequest. Entiendes la idea, ¿sí? Las otras excepciones también se manejan de manera similar.
Línea 34: finalmente, el modelo de respuesta api creado se serializa y se envía como respuesta.

Antes de ejecutar esta implementación, asegúrese de no dejar de agregar este middleware a la canalización de la aplicación. Abra el método Startup.cs/Configure y agregue la siguiente línea.

app.UseMiddleware<ErrorHandlerMiddleware>();

Asegúrese de comentar o eliminar el middleware predeterminado de UseExceptionHandler, ya que puede causar conflictos no deseados. No tiene sentido tener varios middlewares haciendo lo mismo, ¿sí?

También asumo que ha realizado los cambios necesarios que arrojarán la excepción SomeException en el método Get del controlador predeterminado con el que está trabajando.

Una vez hecho esto, ejecutemos la aplicación y veamos cómo se muestra el error en Swagger.

¡Ahí tienes! Puede ver lo bien construida que está la respuesta y lo fácil que es leer lo que la API tiene que decirle al cliente. Ahora, tenemos un mecanismo de manejo de errores completamente personalizado, todo en un solo lugar. Y sí, por supuesto, como se mencionó anteriormente, siempre puede agregar más propiedades a la clase Respuestas API que se adapte a las necesidades de su aplicación.

He estado usando este enfoque literalmente para todos mis proyectos de código abierto, y es Con eso, terminemos el artículo por ahora. 

Resumen

En este artículo, analizamos varias formas de implementar el control de excepciones en nuestras aplicaciones ASP.NET Core. El enfoque favorito definitivamente debería ser aquel en el que implementamos el Manejo de excepciones globales en ASP.NET Core usando Middlewares personalizados. También puede encontrar el  código fuente completo en mi Github aquí . ¿Tiene alguna sugerencia o pregunta? Siéntase libre de dejarlos en la sección de comentarios a continuación. ¡Gracias y feliz codificación!

Fuente: https://codewithmukesh.com/blog/global-exception-handling-in-aspnet-core/  

#aspdotnet #dotnet 

What is GEEK

Buddha Community

jQuery Ajax CRUD in ASP.NET Core MVC with Modal Popup

In this article, we’ll discuss how to use jQuery Ajax for ASP.NET Core MVC CRUD Operations using Bootstrap Modal. With jQuery Ajax, we can make HTTP request to controller action methods without reloading the entire page, like a single page application.

To demonstrate CRUD operations – insert, update, delete and retrieve, the project will be dealing with details of a normal bank transaction. GitHub repository for this demo project : https://bit.ly/33KTJAu.

Sub-topics discussed :

• Form design for insert and update operation.
• Display forms in modal popup dialog.
• Form post using jQuery Ajax.
• Implement MVC CRUD operations with jQuery Ajax.
• Loading spinner in .NET Core MVC.
• Prevent direct access to MVC action method.

Create ASP.NET Core MVC Project

In Visual Studio 2019, Go to File > New > Project (Ctrl + Shift + N).

From new project window, Select Asp.Net Core Web Application_._

Once you provide the project name and location. Select Web Application(Model-View-Controller) and uncheck HTTPS Configuration. Above steps will create a brand new ASP.NET Core MVC project.

Setup a Database

Let’s create a database for this application using Entity Framework Core. For that we’ve to install corresponding NuGet Packages. Right click on project from solution explorer, select Manage NuGet Packages_,_ From browse tab, install following 3 packages.

Now let’s define DB model class file – /Models/TransactionModel.cs.

public class TransactionModel
{
    [Key]
    public int TransactionId { get; set; }

    [Column(TypeName ="nvarchar(12)")]
    [DisplayName("Account Number")]
    [Required(ErrorMessage ="This Field is required.")]
    [MaxLength(12,ErrorMessage ="Maximum 12 characters only")]
    public string AccountNumber { get; set; }

    [Column(TypeName ="nvarchar(100)")]
    [DisplayName("Beneficiary Name")]
    [Required(ErrorMessage = "This Field is required.")]
    public string BeneficiaryName { get; set; }

    [Column(TypeName ="nvarchar(100)")]
    [DisplayName("Bank Name")]
    [Required(ErrorMessage = "This Field is required.")]
    public string BankName { get; set; }

    [Column(TypeName ="nvarchar(11)")]
    [DisplayName("SWIFT Code")]
    [Required(ErrorMessage = "This Field is required.")]
    [MaxLength(11)]
    public string SWIFTCode { get; set; }

    [DisplayName("Amount")]
    [Required(ErrorMessage = "This Field is required.")]
    public int Amount { get; set; }

    [DisplayFormat(DataFormatString = "{0:MM/dd/yyyy}")]
    public DateTime Date { get; set; }
}

C#Copy

Here we’ve defined model properties for the transaction with proper validation. Now let’s define  DbContextclass for EF Core.

#asp.net core article #asp.net core #add loading spinner in asp.net core #asp.net core crud without reloading #asp.net core jquery ajax form #asp.net core modal dialog #asp.net core mvc crud using jquery ajax #asp.net core mvc with jquery and ajax #asp.net core popup window #bootstrap modal popup in asp.net core mvc. bootstrap modal popup in asp.net core #delete and viewall in asp.net core #jquery ajax - insert #jquery ajax form post #modal popup dialog in asp.net core #no direct access action method #update #validation in modal popup

MVC User Registration & Login with ASP.NET Core Identity

User registration and authentication are mandatory in any application when you have little concern about privacy. Hence all most all application development starts with an authentication module. In this article, we will discuss the quickest way to use **ASP.NET Core Identity for User Login and Registration **in a new or existing MVC application.

Sub-topics discussed :

• How to add ASP.NET Core Identity to MVC application.
• Customize ASP.NET Core Identity.
• Identity.UI Design Customization.
• Next step.

Background

ASP.NET Core Identity is an API, which provides both user interface(UI) and functions for user authentication, registration, authorization, etc. Modules/ APIs like this will really be helpful and fasten the development process. It comes with ASP.NET Core Framework and used in many applications before. Which makes the API more dependable and trustworthy.

ASP.NET Core MVC with user authentication can easily be accomplished using Identity.UI. While creating the MVC project, you just need to select Authentication as Individual User Accounts.

The rest will be handled by ASP.NET Core Identity UI. It already contains razor view pages and backend codes for an authentication system. But that’s not what we want in most of the cases. we want to customize ASP.NET Core Identity as per our requirement. That’s what we do here.

Create an ASP.NET Core MVC Project

First of all, I will create a brand new ASP.NET Core MVC application without any authentication selected. We could add ASP.NET Core Identity later into the project.

In Visual Studio 2019, Go to File > New > Project (Ctrl + Shift + N). From new project window, select ASP.NET Core Web Application.

Once you provide the project name and location. A new window will be opened as follows, Select _Web Application(Model-View-Controller), _uncheck _HTTPS Configuration _and DO NOT select any authentication method. Above steps will create a brand new ASP.NET Core MVC project.

#asp.net core article #asp.net core #add asp.net core identity to existing project #asp.net core identity in mvc #asp.net core mvc login and registration #login and logout in asp.net core

Authorization in asp.net core

#Asp.net core #Asp.net core mvc #Core #Asp.net core tutorials #Asp.net core with entity framework

AllowAnonymous in asp.net core

#Asp.net core #Asp.net core mvc #Core #Asp.net core tutorials #Asp.net core with entity framework

Running WordPress on ASP.NET Core with Peachpie

In this article, you will learn how to use or integrate WordPress in ASP.NET and Running WordPress on ASP.NET Core, without PHP, or any source files on the server. The following demonstration will show you how to add WordPress as a frontend to an existing ASP.NET Core application step by step.

• Also, read CRUD Operation with Razor Pages in ASP.Net Core 3.1

Running WordPress on NET Core

WordPress is a free, simplest, and most popular open-source content management system to create your own website or blog which is written in PHP and paired up with MySQL. WordPress on .Net Core is possible with peachpie, which is a compiler built on top of the Roslyn platform, it’s a set of runtime and base class libraries and everything that allows compiling a PHP project, a group of PHP files into a regular .net project.

Peachpie allows for seamless both-way interoperability between PHP and .NET applications. In simpler terms, this means that one can have some parts of an application written in PHP, while other modules are written in .NET and everything will work together as one application. Here is the original Repository of the WordPress SDK by PeachPie.

Here are the following steps to run WordPress with ASP.Net Core:-

Step1: Open your Visual Studio IDE and Create a new project – > ASP.NET Core Web Application

Step 2: Select Web Application: A project template for creating an ASP.Net Core application with example ASP.Net Razor Pages Content.

#.net core #asp.net #wordpress asp.net core #wordpress on asp.net core #wordpress with asp.net core