Publicada:

.NET 6.0 - Tutorial de autenticación JWT con API de ejemplo

Tutorial creado con .NET 6.0

Otras versiones disponibles:

En este tutorial, veremos un ejemplo simple de cómo implementar la autenticación JWT (JSON Web Token) personalizada en una API .NET 6.0 con C#.

Para obtener un ejemplo ampliado que incluye tokens de actualización, consulte .NET 6.0 - JWT Authentication with Refresh Tokens Tutorial with Example API.

La API de ejemplo tiene solo dos puntos finales/rutas para demostrar la autenticación con JWT y el acceso a una ruta restringida con JWT:

  • /users/authenticate: ruta pública que acepta solicitudes HTTP POST que contienen el nombre de usuario y la contraseña en el cuerpo. Si el nombre de usuario y la contraseña son correctos, se devuelve un token de autenticación JWT y los detalles del usuario.
  • /users: ruta segura que acepta solicitudes HTTP GET y devuelve una lista de todos los usuarios de la aplicación si el encabezado de autorización HTTP contiene un token JWT válido. Si no hay un token de autenticación o el token no es válido, se devuelve una respuesta 401 no autorizada.

El proyecto del tutorial está disponible en GitHub en https://github.com/cornflourblue/dotnet-6-jwt-authentication-api.


Contenidos del tutorial


Herramientas necesarias para ejecutar el ejemplo de .NET 6.0 JWT localmente

Para desarrollar y ejecutar aplicaciones .NET 6.0 localmente, descargue e instale lo siguiente:

  • SDK de .NET - incluye el tiempo de ejecución de .NET y las herramientas de línea de comandos
  • Visual Studio Code - editor de código que se ejecuta en Windows, Mac y Linux
  • Extensión de C# para Visual Studio Code - agrega compatibilidad con VS Code para desarrollar aplicaciones .NET


Ejecute la API de autenticación .NET JWT localmente

  1. Descargue o clone el código del proyecto del tutorial desde https://github.com/cornflourblue/dotnet-6-jwt-authentication-api
  2. Inicie la API ejecutando dotnet run desde la línea de comando en la carpeta raíz del proyecto (donde se encuentra el archivo WebApi.csproj), debería ver el mensaje Now listening on: http://localhost:4000. Siga las instrucciones a continuación para probar con Postman o conectarse con una de las aplicaciones de ejemplo de una sola página disponibles (Angular, React, Vue o Blazor).

NOTA: También puede iniciar la aplicación en modo de depuración en VS Code abriendo la carpeta raíz del proyecto en VS Code y presionando F5 o seleccionando Depurar -> Inicie la depuración desde el menú superior. La ejecución en modo de depuración le permite adjuntar puntos de interrupción para pausar la ejecución y recorrer el código de la aplicación. Para obtener más información sobre la depuración de .NET en VS Code, consulte VS Code + .NET - Debug a .NET Web App in Visual Studio Code.


Pruebe la API de autenticación JWT de .NET 6.0 con Postman

Postman es una gran herramienta para probar API, puede descargarla en https://www.postman.com/descargas.

A continuación, se incluyen instrucciones sobre cómo usar Postman para autenticar a un usuario para obtener un token JWT de la API y luego realizar una solicitud autenticada con el token JWT para recuperar una lista de usuarios de la API.

Cómo autenticar a un usuario con Postman

Para autenticar a un usuario con la API y obtener un token JWT, siga estos pasos:

  1. Abra una nueva pestaña de solicitud haciendo clic en el botón más (+) al final de las pestañas.
  2. Cambie el método HTTP a POST con el selector desplegable a la izquierda del campo de entrada de URL.
  3. En el campo URL ingrese la dirección de la ruta de autenticación de su API local - http://localhost:4000/users/authenticate.
  4. Seleccione la pestaña Body debajo del campo URL, cambie el botón de opción de tipo de cuerpo a raw y cambie el selector desplegable de formato a JSON .
  5. Ingrese un objeto JSON que contenga el nombre de usuario y la contraseña de prueba en el área de texto Body:
    {
        "username": "test",
        "password": "test"
    }
  6. Haga clic en el botón Send, debería recibir "200 OK" respuesta con los detalles del usuario y un token JWT en el cuerpo de la respuesta, haga una copia del valor del token porque lo usaremos en el siguiente paso para realizar una solicitud autenticada.

Esta es una captura de pantalla de Postman después de enviar la solicitud y autenticar al usuario:


Cómo realizar una solicitud autenticada para recuperar todos los usuarios

Para realizar una solicitud autenticada utilizando el token JWT del paso anterior, siga estos pasos:

  1. Abra una nueva pestaña de solicitud haciendo clic en el botón más (+) al final de las pestañas.
  2. Cambie el método HTTP a GET con el selector desplegable a la izquierda del campo de entrada de URL.
  3. En el campo URL ingrese la dirección de la ruta de los usuarios de su API local - http://localhost:4000/users.
  4. Seleccione la pestaña Authorization debajo del campo URL, establezca el selector Type en Bearer Token y pegue el token JWT de la autenticación anterior. acceda al campo Token.
  5. Haga clic en el botón Send, debería recibir "200 OK" respuesta que contiene una matriz JSON con todos los registros de usuario en el sistema (solo el usuario de prueba en el ejemplo).

Esta es una captura de pantalla de Postman después de realizar una solicitud autenticada para obtener todos los usuarios:

 


Conecte una aplicación Angular a la API de autenticación de .NET JWT

Para obtener detalles completos sobre la aplicación Angular de ejemplo, consulte la publicación Angular 14 - Ejemplo y Tutorial de Autenticación JWT. Pero para ponerse en marcha rápidamente, solo siga los pasos a continuación.

  1. Instalar Node.js y npm desde https://nodejs.org.
  2. Descargue o clone el código del tutorial de Angular desde https://github.com/cornflourblue/angular-14-jwt-authentication-example
  3. Instale todos los paquetes npm necesarios ejecutando npm install o npm i desde la línea de comandos en la carpeta raíz del proyecto (donde se encuentra el package.json).
  4. Elimine o comente la línea debajo del comentario // provider used to create fake backend ubicado en el archivo /src/app/app.module.ts.
  5. Inicie la aplicación ejecutando npm start desde la línea de comando en la carpeta raíz del proyecto, esto iniciará un navegador que muestra la aplicación de ejemplo de Angular y debe estar conectado con .NET 6.0 JWT Auth API que ya tiene en ejecución.


Conecte una aplicación React a la API de autenticación .NET JWT

Para obtener detalles completos sobre la aplicación React de ejemplo, consulte la publicación React 18 + Redux - Ejemplo y tutorial de autenticación JWT. Pero para ponerse en marcha rápidamente, solo siga los pasos a continuación.

  1. Instalar Node.js y npm desde https://nodejs.org.
  2. Descargue o clone el código del tutorial de React desde https://github.com/cornflourblue/react-18-redux-jwt-authentication-example
  3. Instale todos los paquetes npm necesarios ejecutando npm install desde la línea de comando en la carpeta raíz del proyecto (donde se encuentra el package.json).
  4. Elimine o comente las 2 líneas debajo del comentario // setup fake backend ubicado en el archivo /src/index.js.
  5. Inicie la aplicación ejecutando npm start desde la línea de comando en la carpeta raíz del proyecto
  6. Abra un navegador y vaya a la aplicación en http://localhost:3000, la aplicación de ejemplo de React debe estar conectado con .NET 6.0 JWT Auth API que ya tiene en ejecución.


Conecte una aplicación Vue a la API de autenticación de .NET JWT

Para obtener detalles completos sobre la aplicación Vue JWT de ejemplo, consulte la publicación Vue 3 + Pinia - Tutorial y ejemplo de autenticación JWT. Pero para ponerse en marcha rápidamente, solo siga los pasos a continuación.

  1. Instalar Node.js y npm desde https://nodejs.org.
  2. Descargue o clone el código del tutorial de Vue desde https://github.com/cornflourblue/vue-3-pinia-jwt-authentication-example
  3. Instale todos los paquetes npm necesarios ejecutando npm install desde la línea de comando en la carpeta raíz del proyecto (donde se encuentra el package.json).
  4. Elimine o comente las 2 líneas debajo del comentario // setup fake backend ubicado en el archivo /src/main.js.
  5. Inicie la aplicación ejecutando npm run dev desde la línea de comando en la carpeta raíz del proyecto
  6. Abra un navegador y vaya a la aplicación en http://localhost:3000, la aplicación de ejemplo de Vue debe estar conectado con .NET 6.0 JWT Auth API que ya tiene en ejecución.


Conecte una aplicación Blazor WebAssembly (WASM) a la API de autenticación de .NET JWT

Para obtener detalles completos sobre la aplicación Blazor de ejemplo, consulte la publicación Blazor WebAssembly - JWT Authentication Example & Tutorial. Pero para ponerse en marcha rápidamente, solo siga los pasos a continuación.

  1. Descargue o clone el código del proyecto del tutorial desde https://github.com/cornflourblue/blazor-webassembly-jwt-authentication-example
  2. Cambie la configuración "fakeBackend" a "false" en el archivo /wwwroot/appsettings.json.
  3. Inicie la aplicación ejecutando dotnet run desde la línea de comando en la carpeta raíz del proyecto (donde se encuentra el archivo BlazorApp.csproj)
  4. Abra una nueva pestaña del navegador y vaya a la URL http://localhost:5000, la aplicación Blazor debe estar conectada con la API de autenticación JWT de .NET 6.0 que ya está ejecutando.

NOTA: para habilitar la recarga en caliente (hot reloading) durante el desarrollo para que la aplicación se reinicie automáticamente cuando se cambia un archivo, inicie la aplicación con el comando dotnet watch run.


.NET 6.0 Estructura del proyecto de la API de autenticación JWT

El proyecto tutorial está organizado en las siguientes carpetas:
Controllers: defina los puntos finales/rutas para la API web, los controladores son el punto de entrada a la API web desde las aplicaciones cliente a través de solicitudes http.
Models: representan modelos de solicitud y respuesta para métodos de controlador, los modelos de solicitud definen los parámetros para las solicitudes entrantes y los modelos de respuesta se pueden usar para definir qué datos se devuelven.
Services: contiene lógica comercial, validación y código de acceso a datos.
Entities: representan los datos de la aplicación.
Helpers: cualquier cosa que no encaje en las carpetas anteriores.

Haga clic en cualquiera de los enlaces a continuación para saltar a una descripción de cada archivo junto con su código:

 

Controlador de usuarios de .NET JWT

Ruta: /Controllers/UsersController.cs

El controlador de usuarios de .NET define y maneja todas las rutas/puntos finales para la API que se relacionan con los usuarios, esto incluye la autenticación y las operaciones CRUD estándar. Dentro de cada ruta, el controlador llama al servicio de usuario para realizar la acción requerida que mantiene al controlador 'ajustado' y completamente separado de la lógica empresarial y el código de acceso a datos.

Las rutas restringidas a usuarios autenticados están decoradas con el atributo [Authorize]. La lógica de autenticación se implementa en el atributo de autorización personalizado.

namespace WebApi.Controllers;

using Microsoft.AspNetCore.Mvc;
using WebApi.Helpers;
using WebApi.Models;
using WebApi.Services;

[ApiController]
[Route("[controller]")]
public class UsersController : ControllerBase
{
    private IUserService _userService;

    public UsersController(IUserService userService)
    {
        _userService = userService;
    }

    [HttpPost("authenticate")]
    public IActionResult Authenticate(AuthenticateRequest model)
    {
        var response = _userService.Authenticate(model);

        if (response == null)
            return BadRequest(new { message = "Username or password is incorrect" });

        return Ok(response);
    }

    [Authorize]
    [HttpGet]
    public IActionResult GetAll()
    {
        var users = _userService.GetAll();
        return Ok(users);
    }
}
 

Entidad de usuario de .NET JWT

Ruta: /Entities/User.cs

La clase de entidad de usuario representa los datos de un usuario en la aplicación. Las clases de entidad se usan para pasar datos entre diferentes partes de la aplicación (p. ej., entre servicios y controladores) y se pueden usar para devolver datos de respuesta http desde los métodos de acción del controlador. Si es necesario devolver varios tipos de entidades u otros datos personalizados desde un método de controlador, se debe crear una clase de modelo personalizado en la carpeta Models para la respuesta.

El atributo [JsonIgnore] evita que la propiedad de la contraseña se serialice y se devuelva en las respuestas de la API.

namespace WebApi.Entities;

using System.Text.Json.Serialization;

public class User
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Username { get; set; }

    [JsonIgnore]
    public string Password { get; set; }
}
 

Clase de configuración de la aplicación .NET JWT

Ruta: /Helpers/AppSettings.cs

La clase de configuración de la aplicación contiene propiedades definidas en el archivo appsettings.json y se usa para acceder a la configuración de la aplicación a través de objetos que se insertan en clases mediante el sistema de inyección de dependencia (DI) integrado de .NET. Por ejemplo, el servicio de usuario accede a la configuración de la aplicación a través de un IOptions<AppSettings> appSettings objeto que se inyecta en el constructor.

La asignación de secciones de configuración a clases se realiza en el archivo Program.cs.

namespace WebApi.Helpers;

public class AppSettings
{
    public string Secret { get; set; }
}
 

Atributo de autorización personalizado de .NET

Ruta: /Helpers/AuthorizeAttribute.cs

El atributo de autorización personalizado se agrega a los métodos de acción del controlador que requieren que el usuario esté autenticado.

La autorización se realiza mediante el método OnAuthorization que comprueba si hay un usuario autenticado adjunto a la solicitud actual (context.HttpContext.Items["User"]). El middleware jwt personalizado adjunta un usuario autenticado si la solicitud contiene un token de acceso JWT válido.

En caso de autorización exitosa, no se realiza ninguna acción y la solicitud se pasa al método de acción del controlador; si la autorización falla, se devuelve una respuesta 401 No autorizado.

namespace WebApi.Helpers;

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using WebApi.Entities;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class AuthorizeAttribute : Attribute, IAuthorizationFilter
{
    public void OnAuthorization(AuthorizationFilterContext context)
    {
        var user = (User)context.HttpContext.Items["User"];
        if (user == null)
        {
            // not logged in
            context.Result = new JsonResult(new { message = "Unauthorized" }) { StatusCode = StatusCodes.Status401Unauthorized };
        }
    }
}
 

Middleware JWT personalizado de .NET

Ruta: /Helpers/JwtMiddleware.cs

El middleware JWT personalizado comprueba si hay un token en el encabezado de la solicitud Authorization y, de ser así, intenta:

  1. Validar el token
  2. Extraiga la identificación de usuario del token
  3. Adjunte el usuario autenticado a la colección HttpContext.Items actual para que sea accesible dentro del alcance de la solicitud actual

Si no hay ningún token en el encabezado de la solicitud o si alguno de los pasos anteriores falla, ningún usuario se vinculará al contexto http y la solicitud solo podrá acceder a las rutas públicas. La autorización la realiza el atributo de autorización personalizado que comprueba que un usuario está adjunto al contexto http, si la autorización falla un 401 No autorizado se devuelve la respuesta.

namespace WebApi.Helpers;

using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Text;
using WebApi.Services;

public class JwtMiddleware
{
    private readonly RequestDelegate _next;
    private readonly AppSettings _appSettings;

    public JwtMiddleware(RequestDelegate next, IOptions<AppSettings> appSettings)
    {
        _next = next;
        _appSettings = appSettings.Value;
    }

    public async Task Invoke(HttpContext context, IUserService userService)
    {
        var token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();

        if (token != null)
            attachUserToContext(context, userService, token);

        await _next(context);
    }

    private void attachUserToContext(HttpContext context, IUserService userService, string token)
    {
        try
        {
            var tokenHandler = new JwtSecurityTokenHandler();
            var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
            tokenHandler.ValidateToken(token, new TokenValidationParameters
            {
                ValidateIssuerSigningKey = true,
                IssuerSigningKey = new SymmetricSecurityKey(key),
                ValidateIssuer = false,
                ValidateAudience = false,
                // set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later)
                ClockSkew = TimeSpan.Zero
            }, out SecurityToken validatedToken);

            var jwtToken = (JwtSecurityToken)validatedToken;
            var userId = int.Parse(jwtToken.Claims.First(x => x.Type == "id").Value);

            // attach user to context on successful jwt validation
            context.Items["User"] = userService.GetById(userId);
        }
        catch
        {
            // do nothing if jwt validation fails
            // user is not attached to context so request won't have access to secure routes
        }
    }
}
 

.NET JWT Modelo de solicitud de autenticación

Ruta: /Models/AuthenticateRequest.cs

El modelo de solicitud de autenticación define los parámetros para las solicitudes entrantes a la ruta /users/authenticate, se adjunta a la ruta como el parámetro del método de acción Authenticate de el controlador de usuarios. Cuando la ruta recibe una solicitud HTTP POST, los datos del cuerpo se vinculan a una instancia de la clase AuthenticateRequest, se validan y pasan al método.

Las anotaciones de datos .NET se utilizan para manejar automáticamente la validación del modelo, el atributo [Required] establece tanto el nombre de usuario como la contraseña como campos obligatorios, por lo que si falta alguno, la API devuelve un mensaje de error de validación.

namespace WebApi.Models;

using System.ComponentModel.DataAnnotations;

public class AuthenticateRequest
{
    [Required]
    public string Username { get; set; }

    [Required]
    public string Password { get; set; }
}
 

.NET JWT modelo de respuesta de autenticación

Ruta: /Models/AuthenticateResponse.cs

El modelo de respuesta de autenticación define los datos devueltos después de una autenticación exitosa, incluye detalles básicos del usuario y un token de acceso JWT.

namespace WebApi.Models;

using WebApi.Entities;

public class AuthenticateResponse
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Username { get; set; }
    public string Token { get; set; }


    public AuthenticateResponse(User user, string token)
    {
        Id = user.Id;
        FirstName = user.FirstName;
        LastName = user.LastName;
        Username = user.Username;
        Token = token;
    }
}
 

Servicio de usuario de .NET JWT

Ruta: /Services/UserService.cs

El servicio de usuario contiene métodos para autenticar las credenciales de usuario y devolver un token JWT, obtener todos los usuarios en la aplicación y obtener un solo usuario por ID.

Codifiqué la matriz de usuarios en el ejemplo para mantenerla enfocada en la autenticación JWT, en una aplicación de producción se recomienda almacenar registros de usuarios en una base de datos con contraseñas cifradas. Para ver un ejemplo extendido que incluye compatibilidad con el registro de usuarios y almacena datos con Entity Framework, consulte .NET 6.0 - User Registration and Login Tutorial with Example API.

La parte superior del archivo contiene una interfaz que define el servicio de usuario, debajo está la clase de servicio de usuario concreta que implementa la interfaz.

En una autenticación exitosa, el método Authenticate() genera un JWT (JSON Web Token) usando la clase JwtSecurityTokenHandler que genera un token que se firma digitalmente usando una clave secreta almacenada en appsettings.json. El token JWT se devuelve a la aplicación cliente, que debe incluirlo en el encabezado de autorización HTTP de las solicitudes posteriores para proteger las rutas.

namespace WebApi.Services;

using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using WebApi.Entities;
using WebApi.Helpers;
using WebApi.Models;

public interface IUserService
{
    AuthenticateResponse Authenticate(AuthenticateRequest model);
    IEnumerable<User> GetAll();
    User GetById(int id);
}

public class UserService : IUserService
{
    // users hardcoded for simplicity, store in a db with hashed passwords in production applications
    private List<User> _users = new List<User>
    {
        new User { Id = 1, FirstName = "Test", LastName = "User", Username = "test", Password = "test" }
    };

    private readonly AppSettings _appSettings;

    public UserService(IOptions<AppSettings> appSettings)
    {
        _appSettings = appSettings.Value;
    }

    public AuthenticateResponse Authenticate(AuthenticateRequest model)
    {
        var user = _users.SingleOrDefault(x => x.Username == model.Username && x.Password == model.Password);

        // return null if user not found
        if (user == null) return null;

        // authentication successful so generate jwt token
        var token = generateJwtToken(user);

        return new AuthenticateResponse(user, token);
    }

    public IEnumerable<User> GetAll()
    {
        return _users;
    }

    public User GetById(int id)
    {
        return _users.FirstOrDefault(x => x.Id == id);
    }

    // helper methods

    private string generateJwtToken(User user)
    {
        // generate token that is valid for 7 days
        var tokenHandler = new JwtSecurityTokenHandler();
        var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
        var tokenDescriptor = new SecurityTokenDescriptor
        {
            Subject = new ClaimsIdentity(new[] { new Claim("id", user.Id.ToString()) }),
            Expires = DateTime.UtcNow.AddDays(7),
            SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
        };
        var token = tokenHandler.CreateToken(tokenDescriptor);
        return tokenHandler.WriteToken(token);
    }
}
 

Configuración de la aplicación .NET JWT

Ruta: /appsettings.json

Archivo de configuración raíz que contiene la configuración de la aplicación para todos los entornos.

IMPORTANTE: La API utiliza la propiedad "Secret" para firmar y verificar los tokens JWT para la autenticación, actualícelo con su propia cadena aleatoria para asegurarse de que nadie más pueda generar un JWT para obtener acceso no autorizado. acceso a su aplicación.

{
    "AppSettings": {
        "Secret": "THIS IS USED TO SIGN AND VERIFY JWT TOKENS, REPLACE IT WITH YOUR OWN SECRET, IT CAN BE ANY STRING"
    },
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
        }
    }
}
 

Configuración OmniSharp

Ruta: /omnisharp.json

Este archivo contiene opciones de configuración para la extensión de C# en VS Code. La opción useBundledOnly le dice a la extensión de C# que use la versión incluida de MSBuild en lugar de la versión global para evitar errores si tiene una versión anterior de MSBuild instalada globalmente (por ejemplo, como parte de Visual Studio).

{
    "msbuild": {
        "useBundledOnly": true
    }
}
 

Programa .NET JWT

Ruta: /Program.cs

El archivo de programa .NET 6 contiene declaraciones de nivel superior que el nuevo compilador de C# 10 convierte en un método y clase Main() para el programa .NET . El método Main() es el punto de entrada para una aplicación .NET, cuando se inicia una aplicación busca el método Main() para comenzar la ejecución. Las declaraciones de nivel superior se pueden ubicar en cualquier parte del proyecto, pero generalmente se colocan en el archivo Program.cs, solo un archivo puede contener declaraciones de nivel superior dentro de una aplicación .NET.

La clase WebApplication maneja el inicio de la aplicación, la administración de por vida, la configuración del servidor web y más. Primero se crea un WebApplicationBuilder llamando al método estático WebApplication.CreateBuilder(args), el constructor se usa para configurar servicios para inyección de dependencia (DI), se crea una instancia de WebApplication llamando a builder.Build(), la instancia de la aplicación se usa para configurar la canalización de solicitud HTTP (middleware), luego la aplicación se inicia llamando a app.Run().

Envolví las secciones add services... y configure HTTP... entre llaves {} para agruparlas visualmente, los corchetes son completamente opcionales.

Internamente, la clase WebApplicationBuilder llama al método de extensión ConfigureWebHostDefaults() que configura el alojamiento para la aplicación web, incluida la configuración de Kestrel como servidor web, la adición de middleware de filtrado de host y la habilitación de IIS integración. Para obtener más información sobre la configuración predeterminada del generador, consulte https://docs.microsoft.com/aspnet/core/fundamentals/host/generic-host#default-builder-settings.

using WebApi.Helpers;
using WebApi.Services;

var builder = WebApplication.CreateBuilder(args);

// add services to DI container
{
    var services = builder.Services;
    services.AddCors();
    services.AddControllers();

    // configure strongly typed settings object
    services.Configure<AppSettings>(builder.Configuration.GetSection("AppSettings"));

    // configure DI for application services
    services.AddScoped<IUserService, UserService>();
}

var app = builder.Build();

// configure HTTP request pipeline
{
    // global cors policy
    app.UseCors(x => x
        .AllowAnyOrigin()
        .AllowAnyMethod()
        .AllowAnyHeader());

    // custom jwt auth middleware
    app.UseMiddleware<JwtMiddleware>();

    app.MapControllers();
}

app.Run("http://localhost:4000");
 

Archivo .NET 6 CSProj

Ruta: /WebApi.csproj

El csproj (proyecto C#) es un archivo basado en MSBuild que contiene el marco de destino y la información de dependencia del paquete NuGet para la aplicación. La función ImplicitUsings está habilitada, lo que le dice al compilador que genere automáticamente un conjunto de directivas de uso globales basadas en el tipo de proyecto, eliminando la necesidad de incluir muchas declaraciones de uso comunes. Las instrucciones de uso global se generan automáticamente cuando crea el proyecto y se pueden encontrar en el archivo /obj/Debug/net6.0/WebApi.GlobalUsings.g.cs.

Para obtener más información sobre el archivo de proyecto de C#, consulte .NET + MSBuild - C# Project File (.csproj) in a Nutshell.

<Project Sdk="Microsoft.NET.Sdk.Web">
    <PropertyGroup>
        <TargetFramework>net6.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.0" />
        <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.15.0" />
    </ItemGroup>
</Project>

 


Suscríbete o Sígueme para actualizaciones

Suscríbete a mi canal de YouTube o sígueme en Twitter, Facebook o GitHub para recibir notificaciones cuando publique contenido nuevo.

Aparte de la codificación...

Actualmente estoy intentando viajar por Australia en motocicleta con mi esposa Tina en un par de Royal Enfield Himalayan. Puedes seguir nuestras aventuras en YouTube, Instagram y Facebook.


¿Necesita Ayuda .NET?

Buscar fiverr para encontrar ayuda rápidamente de desarrolladores .NET experimentados.