< name = "viewport " content = "width = device width " /> @ ViewBag.Title @ DateTime.Now @RenderBody ()
Aquí es donde existe la llamada al método RenderBody. Podemos esperar que todas las vistas de contenido de nuestra aplicación aparezcan dentro del
La otra expresión dentro de este archivo es ViewBag.Title. ViewBag es una estructura de datos que se puede agregar a cualquier propiedad y cualquier dato que deseeez en ViewBag. Podemos agregar un ViewBag.Title, ViewBag.CurrentDate o cualquier propiedad que queramos en el ViewBag.
Ahora vayamos al archivo index.cshtml.
@model FirstAppDemo.Controllers.HomePageViewModel Inicio ¡Bienvenido!
@foreach (empleado var en Model.Employees) { | @ Html.ActionLink (employee.Id.ToString () , "Detalles ", nuevo {id = employee.Id}) | @ employee.Name |
}
Quitar marcado que ya no necesitamos en la vista de índice. Por lo tanto, podemos eliminar cosas como la etiqueta HTML y la etiqueta head. Tampoco necesitamos el elemento de cuerpo de apertura. o cerrando etiquetas como se muestra en el siguiente programa.
@model FirstAppDemo.Controllers.HomePageViewModel @ {ViewBag.Title = "Iniciol Layout = "~ / Views / Shared / _Layout.cshtml}
¡Bienvenido!
@foreach (empleado var en Model.Employees) { | @ Html.ActionLink (empleado .Id.ToString (), "Detalles ", nuevo {id = employee.Id}) | @ employee.Name |
}
Todavía tenemos que hacer dos cosas:
-
Primero, debemos decirle al marco MVC que queremos usar la vista Diseño. página desde esta vista.
-
En segundo lugar, debemos establecer el título apropiado agregando información en el ViewBag como se muestra en el código anterior.
Guardemos todos los archivos y ejecutemos la aplicación. Una vez iniciada la aplicación, verá la siguiente página de bienvenida.
ASP.NET Core - Iniciando Razor View
En este capítulo hemos iniciado Razor View. Razor View Engine en MVC tiene una convención donde buscará cualquier archivo con el nombre _ViewStart.cshtml y ejecutará el código dentro de ese archivo. antes de ejecutar el código en una vista individual.
-
El código dentro del archivo ViewStart no se puede mostrar en la salida HTML de una página, pero se puede usar para eliminar código duplicado de bloques de código para dentro de las vistas individuales.
-
En nuestro ejemplo, si queremos que cada vista use la vista Diseño que creamos en el último capítulo, podríamos poner el código para definir la vista Diseño en un ViewStart en lugar de tener el código en cada vista.
Ejemplo
Tomemos un ejemplo es sencillo ver cómo funciona. En nuestra aplicación, no queremos que cada vista especifique que su vista de diseño es _Layout.cshtml . Así que haga clic derecho en la carpeta Vistas y seleccione Agregar → Nuevo elemento .
Hay una plantilla específica en ASP.NET MVC para una página ViewStart, luego seleccione MVC View Start Page en el panel central. La parte más importante aquí es que este archivo se llama _ViewStart.cshtml . Ahora haga clic en el botón Agregar.
El uso principal de un archivo ViewStart es definir la vista Layout.
Ahora pasemos a dex.cshtml y corte la línea de diseño, luego agréguela al archivo ViewStart como se muestra en el siguiente programa.
@ {Layout = "~ / Views / Shared /_Layout.cshtml}
-
Cuando el marco MVC va a renderizar una vista, verá si hay un archivo ViewStart en algún lugar de la jerarquía de carpetas.
-
Hemos colocado _ViewStart directamente en nuestra carpeta Vistas. Esto afectará a todas las vistas de todas las carpetas que se encuentran en la carpeta Vistas, así como a las vistas en la carpeta Inicio, así como a la carpeta Compartida, así como a todas las demásossiers controladores que podemos agregar en el futuro.
-
Si tomamos ViewStart y lo colocamos solo en la carpeta Inicio, este pequeño código solo se ejecutará cuando rendericemos una de esas vistas en la carpeta Inicio .
-
Incluso podemos tener varios archivos ViewStart, por lo que podríamos tener un ViewStart.cshtml aquí en la carpeta Vistas que define la vista Diseño para todas las vistas.
-
Pero si quisiéramos cambiar este valor predeterminado para todas las vistas solo en la carpeta Inicio, podríamos tener otro ViewStart en la carpeta Inicio que establezca el diseño en otra cosa .
Hagamos una copia de seguridad de todos los archivos y ejecutemos la aplicación.
Verá que su página de inicio se ve exactamente como antes, y todavía tenemos la vista Diseño en efecto.
ASP.NET Core - Importación de la vista Razor
En este capítulo tenemos la vista Razor'importar. Además del archivo ViewStart, también hay un archivo ViewImports que el marco MVC buscará al representar una vista.
Al igual que el archivo ViewStart, podemos eliminar ViewImports.cshtml en una carpeta, y el archivo ViewImports puede influir en todas las vistas en la jerarquía de carpetas
-
Esta vista es nueva para esta versión de MVC, en la versión anterior de MVC podríamos usar una Archivo de configuración XML para configurar ciertos aspectos del motor de vista de Razor.
-
Estos archivos XML ya no están y estamos usando código en su lugar.
-
El archivo ViewImports es un lugar donde podemos escribir código y colocar directivas comunes para extraer los espacios de nombres que necesitan nuestras vistas.
-
Si hay espacios de nombres que usamos comúnmente en nuestras vistas, es posible que aparezcan directivas de uso una vez ennuestro archivo ViewImports en lugar de tener directivas de uso en cada vista o escriba en el espacio de nombres completo de una class.
Ejemplo
Tomemos un ejemplo simple para ver cómo mover nuestras directivas using a ViewImports . En la vista de índice, tenemos una directiva using para introducir el espacio de nombres FirstAppDemo.Controllers como se muestra en el siguiente programa.
@using FirstAppDemo.Controllers @model HomePageViewModel @ {ViewBag.Title = "Home}
¡Bienvenido!
@foreach (employee var en Model.Employees) { | @ Html.ActionLink (employee.Id.ToString (), "Detalles ", nuevo {id = employee.Id}) | @employee. Nombre |
}
El uso de directivas permitirá que el código generado desde la vista de Razor se compile correctamente. use directivas , el compilador de C # no puedeNo podremos encontrar este tipo de empleado. Para ver el tipo de empleado, eliminemos la directiva using del archivo Index.cshtml .
@model HomePageViewModel @ {ViewBag.Title = "Home}
¡Bienvenido!
@foreach (empleado var en Model.Employees) { | @ Html.ActionLink (employee.Id.ToString (), "Detalles ", nuevo {id = employee.Id}) | @ employee.Name |
}
Ahora ejecute la aplicación.
Verá uno de los errores que indica que el tipo o espacio de nombres HomePageViewModel no se pudo encontrar. Esto puede deberse a que varias de sus vistas requieren la misma directiva using . Por lo tanto, en lugar de ponerla en cada vista, creemos una importación de vista en la carpeta Las vistas agregarán declaraciones de uso a cada vista con solo hacer clic con el botón derecho en la carpeta Vistas y seleccionar Agregar → Nuevo elemento.
< origen de datos-srcset="https://www.hebergementwebs.com/image/55/55c5c254a6d1ac79ee6bb5f98bf8bcc2.webp/asp-net-core-guide-rapide-388.webp"type = "image/webp"media = " (ancho mínimo : 800px) "> 
En el panel central, seleccione la página MVC View Imports.el nombre predeterminado es _ViewImports.cshtml. Al igual que ViewStart, no podemos usar este archivo para renderizar HTML, así que hagamos clic en el botón Agregar.
Ahora agregue la directiva using en t sound en el archivo _ViewImports.cshtml como se muestra a continuación.
@ usando FirstAppDemo.Controllers
Ahora todas las vistas que aparecen en esta carpeta o cualquier subcarpeta podrán usar tipos de FirstAppDemo.Controllers sin especificar esa instrucción using exacta. Ejecutemos en nueva su aplicación y verá que la vista está funcionando ahora.
ASP.NET Core - Asistentes de etiquetas de Razor
Los asistentes de etiquetas permitir que el código del lado del servidor participe en la creación y representación de elementos HTML en Razor Files. Los asistentes de etiquetas son una nueva característica similar a los asistentes de HTML, que nos ayudan a representar HTML.
-
Hay muchos asistentes de etiquetas integradosres para tareas comunes, como crear formularios, enlaces, cargar elementos, etc. Los asistentes de etiquetas se crean en C # y apuntan a elementos HTML según el nombre del elemento, el nombre del atributo o la etiqueta principal.
-
Por ejemplo, el LabelTagHelper integrado puede apuntar al elemento HTML
-
Si está familiarizado con HTML Helpers, Tag Helpers reducen las transiciones explícitas entre HTML y C # en las vistas de Razor.
Para usar Tag Helpers, necesitamos instalar una biblioteca NuGet y también agregar una directiva addTagHelper a las vistas que usan estos tag helpers. Haga clic derecho en su proyecto en el Explorador de soluciones y seleccione Administrar paquetes NuGet ....
Busque Microsoft.AspNet.Mvc.TagHelpers y haga clic en el botón Instalar.
Recibirá el siguiente cuadro de diálogo Vista previa.
Haga clic en el botón Aceptar.
Haga clic en el botón Acepto . Una vez que Microsoft.AspNet.Mvc.TagHelpers esté instalado, navegue hasta el archivo project.json.
{ "versión ": "1.0.0 - * ", "compilationOptions ": { "emitEntryPoint ": true}, "dependencias ": {" Microsoft.AspNet.Mvc ": " 6.0.0-rc1-final ", " Microsoft .AspNet.Diagnostics ": " 1.0.0-rc1-final ", " Microsoft.AspNet.IISPlatformHandler ": " 1.0.0-rc1-final ", " Microsoft.AspNet.Server.Kestrel ": " 1.0.0-rc1-final ", " Microsoft.AspNet. StaticFiles ": " 1.0.0-rc1-final ", " EntityFramework.MicrosoftSqlServer ": " 7.0.0 -rc1-final ", " EntityFramework.Commands ": " 7.0.0- rc1-final ", " Microsoft.AspNet.Mvc.TagHelpers ": " 6.0.0-rc1-final "}, " comandos ": {" web ": " Microsoft.AspNet. Server.Kestrel ", " ef ": " EntityFramework.Commands "}, " frameworks ": {" dnx451 ": {}, " dnxcore50 ": {}}, " excluir ": [" www root ", " node_modules "], " publishExclude ": [" **. usuario ", " **. vspscc "]}
En la sección de dependencias, verá que " Microsoft.AspNet.Mvc.TagHelpers ": " 6.0.0-rc1-final " se agrega.
-
Ahora cualquiera puede crear un asistente de etiquetas, así que si estás pensando en un asistente de etiquetas, tienes necesita, puede escribir su propio asistente de etiquetas.
-
Puede colocarlo directamente en el proyecto de su aplicación, pero debe informar al motor de vista de Razor. asistente de etiquetas.
-
De forma predeterminada, el cliente no los renderiza simplemente, aunque estos asistentes de etiquetas parecen combinarse con el HTML.
-
Razor llamará al código para procesar una etiqueta auxiliar; puede eliminarse de HTML y también puede agregar HTML adicional.
-
hay muchas cosas maravillosas que puedes hacer con un asasistente de etiquetas, pero debe registrar sus asistentes de etiquetas con Razor, incluso los asistentes de etiquetas de Microsoft, para que Razor detecte estas etiquetas en el marcado y pueda llamar al código que procesa el asistente de etiquetas .
-
La directiva para hacer esto es addTagHelper, y puede ponerlo en una vista individual, o si planea usar ayudantes de etiquetas en toda la aplicación , puede usar addTagHelper en el archivo ViewImports como se muestra a continuación.
@using FirstAppDemo.Controllers @addTagHelper "*, Microsoft.AspNet.Mvc.TagHelpers "
La sintaxis para registrar todos los asistentes de etiquetas que están en un ensamblado es usar una coma asterisco (*,) y luego el nombre del ensamblado, Microsoft.AspNet.Mvc.TagHelpers . Debido a que el primer elemento aquí es un nombre de tipo, aquí es donde podríamos enumerar un culoHay una etiqueta específica si solo desea usar una.
Pero si solo quisiera tomar todos los ayudantes de etiquetas que están en eso, puede usar el asterisco (*) . Hay muchos asistentes de etiquetas disponibles en la biblioteca de ayuda de etiquetas. Echemos un vistazo a la vista de índice.
@model HomePageViewModel @ {ViewBag.Title = "Home}
¡Bienvenido!
@foreach (empleado var en Model.Employees) { | @ Html.ActionLink (employee.Id.ToString (), "Detalles ", nuevo {id = employee.Id}) | @ employee.Name |
}
Ya tenemos un ayudante HTML que usa ActionLink para generar una etiqueta de anclaje que apuntará a una URL que nos permita 'Acceda a los detalles del empleado.
Primero agreguemos la acción Detalles en el controlador doméstico como se muestra en el siguiente programa.
public IActionResult Details (int id) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (context); var model = sqlData.Get (id); if (model == null) {return RedirectToAction ( "Index ");} return View (model);}
Ahora necesitamos agregar una vista para la acción de Detalles. Creemos una nueva vista en la carpeta Vistas → Inicio y llamémosla Detalles .cshtml y agregue el siguiente código.
@model FirstAppDemo.Models.Employee @ Model.Name
@ Model.Name
Id: @ Model.Id @ Html.ActionLink ( "Inicio ", "Índice " )
Ahora iniciemos la aplicación.
Cuando haga clic en la identificación de un empleado, lo llevará a la vista de detalles.
Hagamos clic en la primera identificación de empleado.
Ahora, para usar la etiqueta auxiliar para esto, agreguemos la siguiente línea al archivo index.cshtml y eliminemos el ayudante HTML.
Detalles
asp-action = "Detalles " es el nombre de la acción a la que queremos llegar. Si hay un parámetro que desea pasar, puede usar el asistente de etiquetas asp-route y aquí queremos incluir el ID como parámetro para que podamos usar el asistente de etiquetas asp-route-Id.
Aquí está la implementación completa del archivo index.cshtml.
@model HomePageViewModel @ {ViewBag.Title = "Home}
¡Bienvenido!
@foreach (empleado var en Model.Employees) { | Detalles | @ employee.Name |
}
Permítanos ejecutar su aplicación nuevamente. Después de ejecutar la aplicación, verá la siguiente página.
Anteriormente mostramos la ID como el texto del enlace, pero ahora mostramosel texto de Detalles. Ahora hacemos clic en los detalles y creamos la URL correcta usando ayudantes de etiquetas en lugar de ayudantes de HTML.
Ya sea que elija utilizar ayudantes HTML o ayudantes de etiquetas , es realmente una cuestión de preferencia personal. Muchos desarrolladores encuentran que los ayudantes Las etiquetas son más fáciles de crear y mantener.
ASP.NET Core - Formulario de edición de Razor
En este capítulo, continuaremos discutiendo los asistentes de etiquetas. También agregaremos una nueva característica en nuestra aplicación y le dará la capacidad de editar los detalles de un empleado existente. Comenzaremos agregando un enlace en el costado de cada empleado que irá a una acción de Editar en el HomeController.
@model HomePageViewModel @ {ViewBag.Title = "Home}
¡Bienvenido!
@foreach (empleado var en Model.Employees) { | @ empleado.Nombre | Detalles Editar |
}
Aún no tenemos la acción Editar, pero necesitaremos una identificación de empleado que podamos editar. Comencemos por crear una nueva vista haciendo clic derecho en la carpeta Vistas → Inicio y seleccionando Agregar → Nuevos elementos .
En el panel central, seleccione la página de vista MVC; llame Página Edit.cshtml. Ahora haga clic en el botón Agregar.
Agregue el siguiente código al archivo Edit.cshtml .
@model Employee @ {ViewBag.Title = $ " Editar {Model.Name}}
Editar @ Model.Name
Para el título de esta página, podemos decir quedesea editar y luego proporcione el nombre del empleado.
-
El signo de dólar delante de Modificar permitirá que el tiempo de ejecución reemplace Model.Name con un valor que esté en esta propiedad como el nombre del empleado.
-
Dentro de la etiqueta de formulario, podemos usar la etiqueta de ayuda como asp-action y asp-controller. para que cuando el usuario envíe este formulario, vaya directamente a una acción específica del controlador.
-
En este caso, queremos ir a la acción Editar en el mismo controlador y queremos decir explícitamente que para el método en este formulario debe usar un HttpPost .
-
El método predeterminado para un formulario es GET, y no queremos editar a un empleado mediante una operación GET.
-
En la etiqueta de etiqueta, usamos el asistente de etiqueta asp-for que indica que esta es una etiqueta para la propiedadTee Nombre del modelo. Este asistente de etiquetas puede configurar el atributo Html.For para que tenga el valor correcto y establecer el texto interno de esta etiqueta para mostrar realmente lo que queremos, como el nombre de la etiqueta. empleado.
Vayamos a la class HomeController y agreguemos la acción Editar que devuelve la vista que le da al usuario un formulario para editar un empleado, entonces necesitaremos una segunda acción de edición que responderá a un HttpPost como se muestra a continuación.
[HttpGet] Public IActionResult Edit (int id) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); var modelo = sqlData.Get (id); if (modelo == null) {return RedirectToAction ( "Index "); } return View (modelo); }
Primero, necesitamos una acción de edición que responda a una solicitud GET. Necesitará una identificación de empleado. El código aquí será similar acódigo que tenemos en la acción Detalles. Primero extraeremos los datos del empleado que el usuario quiere modificar. También debemos asegurarnos de que el empleado realmente exista. Si no existe, redirigiremos al usuario a la vista de índice. Pero cuando existe un empleado, renderizaremos la vista Editar.
También debemos responder al HttpPost que enviará el formulario.
Agreguemos una nueva class en HomeController .cs como se muestra en el siguiente programa.
public class EmployeeEditViewModel {[Required, MaxLength (80)] public string Name {get; juntos; }}
En la acción de edición que responderá al HttpPost se tomará un EmployeeEditViewModel, pero no un empleado en sí, ya que solo queremos capturar los elementos que tienen forma en el archivo de edición. cshtml.
La siguiente es la implementación de la acción Editar.
[HttpPost]public IActionResult Edit (int id, entrada EmployeeEditViewModel) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); empleado var = sqlData.Get (id); if (employee! = null && ModelState.IsValid) {employee.Name = input.Name; context.SaveChanges openModal(); devuelve RedirectToAction ( "D etails ", new {id = employee.Id});} return View (employee);}
El formulario de edición siempre debe entregarse desde una URL que tiene un identificador en la URL de acuerdo con nuestras reglas de enrutamiento, algo así como / home / edit / 1 .
-
El formulario siempre se enviará a esta misma URL, /home/edit/1.
El marco MVC puede extraer este identificador de la URL y pasarlo como parámetro.
-
Siempre debemos verificar si ModelState es válido y también asegurarnos de que este empleado esté en la base de datos y que no sea nulo antes de ir '' realizar una operaciónactualizar en la base de datos.
-
Si nada de esto es cierto, devolveremos una vista y permitiremos que el usuario vuelva a intentarlo. Aunque en una aplicación real con usuarios concurrentes, si el empleado es nulo, alguien podría eliminar los detalles del empleado.
-
Si este empleado no existe, dígale al usuario que el empleado no existe.
-
De lo contrario, compruebe que ModelSt se ha comido. Si ModelState no es válido, devuelve una vista. Esto corrige el cambio y hace que ModelState sea válido.
-
Copie el nombre de la plantilla de la vista de entrada al empleado extraído de la base de datos y guarde los cambios. El método SaveChagnes () volcará todas estas modificaciones en la base de datos.
La siguiente es la implementación completa de HomeController.
usando Microsoft.AspNet.Mvc; utilizandot FirstAppDemo.ViewModels; utilizando FirstAppDemo.Services; utilizando FirstAppDemo.Entities; utilizando FirstAppDemo.Models; utilizando System.Collections.Generic; utilizando System.Linq; utilizando System.ComponentModel.DataAnnotations; espacio de nombres FirstAppDemo.Controllers {HomeController de class pública: Controlador {Índice ViewResult público () {modelo var = nuevo HomePageViewModel openModal(); usando (var context = new FirstAppDemoDbContext ()) {SQLEmployeeData sqlData = new SQLEmployeeData (contexto); model.Employees = sqlData.GetAll openModal(); } return View (modelo); } detalles publi c IActionResult (int id) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); var model = sqlData.Get (id) if (model == null) {return RedirectToAction ( "Index "); } return View (modelo); } [HttpGet] edición pública de IActionResult (int id) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); var modelo = sqlData.Get (id); si (modelo== null) {return RedirectToAction ( "Index "); } return View (modelo); } [HttpPost] Public IActionResult Edit (int id, entrada EmployeeEditViewModel) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); empleado var = sqlData.Get (id); if (employee! = null && ModelState.IsValid) {employee.Name = input.Name; context.SaveChanges openModal(); return RedirectToAction ( "Detalles ", nuevo {id = employee.Id}); } return View (empleado); }} class pública SQLEmployeeData {FirstAppDemoDbContext privado _context {get; juntos; } public SQLEmployeeData (contexto FirstAppDemoDbContext) {_context = contexto; } public void Add (Empleado emp) {_context.Add (emp); _context.SaveChanges openModal(); } Public Employee Get (ID int) {return _context.Employees.FirstOrDefault (e => e.Id == ID); } public IEnumerable GetAll () {return _context.Employees.ToList openModal(); }} Public class HomePageViewModel {público IEnumerable Empleados {get; juntos; }} public class EmployeeEditViewModel {[Requerido, MaxLength (80)] cadena pública Name {get; juntos; }}}
Compilemos el programa y ejecutemos la aplicación.
Ahora tenemos un enlace de edición disponible; Editemos los detalles de Josh haciendo clic en el enlace Editar.
Cambiemos el nombre a Josh Groban.
Haga clic en el botón Guardar.
Puedes ver que el nombre ha sido cambiado a Josh Groban como en la captura de pantalla anterior. Ahora hagamos clic en el enlace Inicio.
En la página de inicio, ahora verá el nombre actualizado.
ASP.NET Core - Descripción general de la identidad
En este capítulo, tenemos brevemente el marco de identidad de ASP.NET Core. El marco de identidad de ASP.NET Core se utiliza para implementar la autenticación mediante Hay muchas opciones para identificar a sus usuarios, incluida la autenticación de Windows y todos los proveedores de identidad de terceros como Google, Microsoft, Facebook y GitHub, etc.
-
El marco de identidad es otra dependencia que agregaremos a nuestra aplicación en el archivo project.js.
-
Este marco que permite agregar funcionalidad donde los usuarios pueden registrarse e iniciar sesión con una contraseña local.
-
El marco también admite la autenticación en dos factores, proveedores de identidad de terceros y otras características.
-
Nos centraremos en los escenarios en los que un usuario puede registrarse, iniciar sesión y cerrar sesión.
Para hacer esto, necesitamos crear una entidad de Usuario y esta class heredará de una class base en el marco de Identidad y la class base que dar a nuestras propiedades de usuario estándar como nombre de usuario y dirección de correo electrónico.
-
Podemos incluir tantas propiedades adicionales como queramos en esta class para almacenar información sobre nuestrousuarios.
-
Necesitamos tomar esta class User y conectarla a una class UserStore proporcionada por Identity framework.
-
UserStore es la class con la que nuestro código hablará para crear usuarios y validar sus contraseñas.
-
En última instancia, un UserStore hablará con una base de datos. El marco de identidad admite Entity Framework y todas las bases de datos que pueden funcionar con Entity Framework.
-
Pero puede implementar su propia UserStore para trabajar con cualquier source de datos.
-
Para trabajar correctamente con Entity Framework, nuestra class User también se conectará a una class IdentityDb.
-
Este es uno que usa un DBContext Entity Framework para hacer el trabajo real de la base de datos.
-
Necesitaremos incluir este IdentityDb en nuestra aplicación heredandode nuestra class DataContext existente de IdentityDb en lugar del DBContext de Entity Framework.
-
Estos son IdentityDb y UserStore que trabajan juntos para almacenar información del usuario y validar las contraseñas de los usuarios, contraseñas hash que se encuentran en la base de datos.
Hay dos elementos de ASP.NET Core Identity Framework que necesitamos conocer
SignInManager
Es uno de los dos elementos del marco de identidad -
-
Como sugiere el nombre, SignInManager puede iniciar sesión como usuario una vez que hayamos validado la contraseña.
-
También podemos use este administrador para desconectar a un usuario.
-
Con la autenticación de formularios, la conexión y desconexión se realiza administrando una cookie.
-
Cuando le decimos al SignInManager que conecte a un usuario, el administrador emite un cookie al navegador del usuario, y el navegador enviará esta cookie en cada solicitud posterior. Esto nos ayuda a identificar a este usuario.
Identity Middleware
Este es el segundo elemento del marco -
-
Leer la cookie enviada por SignInManager e identificar al usuario, e Esto ocurre en el último elemento del framework, el middleware de identidad.
-
Necesitaremos configurar este middleware en nuestra canalización de aplicaciones para procesar la cookie establecida por SignInManager. También veremos otras características de este middleware en los próximos capítulos.
ASP.NET Core - Atributo de autorización
En este capítulo, discutiremos el atributo de autorización. Hasta ahora, en nuestra aplicación, hemos permitido que los usuarios anónimos hagan cualquier cosa. Pueden editar los detalles de los empleados y ver los detalles, pero no tenemos ningunotener la funcionalidad para crear un nuevo empleado. Primero agreguemos la funcionalidad de autoría, y luego restringiremos el acceso de los usuarios usando el atributo Authorize.
Necesitamos comenzar creando una nueva página de Vista MVC en la carpeta Vistas → Inicio y llamarla Create.cshtml y luego agregar el siguiente código.
@model Employee @ {ViewBag.Title = "Create}
Create
@using (Html.BeginForm ()) {@ Html.LabelFor (m => m.Name) @ Html.EditorFor (m => m.Name) @ Html.ValidationMessageFor (m => m.Name)}
Ahora agregaremos el método d 'action en HomeController para POST y GET, como se muestra en el siguiente programa.
[HttpGet] public ViewResult Create () {return View openModal(); } [HttpPost] public IActionResult Create (EmployeeEditViewModel model) {if (ModelState.IsValid) {var employee = new Employee openModal(); employee.Name = model.Name; var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); sqlData.Add (empleado); return RedirectToAction ( "Detalles ", nuevo {id = employee.Id}); } return View openModal(); }
Agreguemos un enlace a Crear vista en el archivo Index.cshtml como se muestra en el siguiente programa.
@model HomePageViewModel @ {ViewBag.Title = "Home}
¡Bienvenido!
@foreach (empleado var en Model.E empleados ) { | @ employee.Name | Detalles Editar |
}
Create Ejecute la aplicación; verá la siguiente página.
En el página de inicio, verá el enlace Crear. Cuando haga clic en el enlace Crear, lo llevará a la vista Crear.
Ingresa un nombre en el campo Nombre y haz clic enUtilice el botón Guardar.
Ahora verá la vista detallada del empleado recién agregado. Hagamos clic en el enlace Inicio.
En esta aplicación, cada usuario puede crear, modificar un empleado y todos pueden ver la vista detallada. Queremos cambiar este comportamiento para que en el futuro, los usuarios anónimos solo puedan ver la lista de empleados en la página de inicio, pero cualquier otra acción requiere que el usuario se identifique e inicie sesión. Podemos hacer esto con Permitir atributo .
Usted puede colocar el atributo Authorize en un controlador o en acciones individuales dentro del controlador.
[Authorize] public class HomeController: Controller {//. ...}
-
Cuando colocamos el atributo Authorize en el controlador mismo, el atributo Authorize se aplica a todos acciones dentro.
-
El marco MVC nono permitirá que una solicitud llegue a una acción protegida por este atributo a menos que el usuario pase una verificación de autorización.
-
De forma predeterminada, si no utiliza ningún otro parámetro, la única verificación que realizará el atributo Authorize es una verificación para asegurarse de que el usuario está conectado para que sepamos su identidad.
-
Pero puede utilizar parámetros para especificar cualquier política de permisos personalizada que desee.
-
También hay un atributo AllowAnonymous . Este atributo es útil cuando desea utilizar el atributo Permitir en un controlador para proteger todas las acciones internas, pero existe una acción única o una o dos acciones que desea desproteger y permitir que los usuarios anónimos 'lograr esta acción específica.
[AllowAnonymous] public ViewResult Index () {var model = new HomePageViewModel openModal(); usando (var context = new FirstAppDemoDbContext ()) {SQLEmployeeData sqlData = new SQLEmployeeData (contexto); model.Employees = sqlData.GetAll openModal(); } return View (modelo); }
Probemos estos atributos en nuestra aplicación. En la aplicación en ejecución, un usuario anónimo puede editar a un empleado.
Queremos cambiar eso y obligar a los usuarios a iniciar sesión e iniciar sesión antes de que podamos editar un empleado. Ahora pasemos al HomeController. Aquí limitaremos el acceso a una o dos acciones. Siempre podemos establecer el atributo Authorize en las acciones específicas que queremos proteger. También podemos establecer el atributo Authorize en el controlador en sí mismo, y este atributo Authorize está en el espacio de nombres Microsoft.AspNet.Authorization.
Ahora usaremos el atributo Authorize y obligaremos a los usuarios a iniciar sesión para ingresar este controlador a excepción dela página de inicio como se muestra en el siguiente programa.
[Authorize] public class HomeController: Controller {[AllowAnonymous] public ViewResult Index () {var model = new HomeP ageViewModel openModal(); usando (var context = new FirstAppDemoDbContext ()) {SQLEmployeeData sqlData = new SQLEmployeeData (contexto); model.Employees = sqlData.GetAll openModal(); } return View (modelo); } Detalles públicos IActionResult (int id) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); var modelo = sqlData.Get (id); if (modelo == null) {return RedirectToAction ( "Index "); } return View (modelo); } [HttpGet] edición pública de IActionResult (int id) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); var modelo = sqlData.Get (id); if (modelo == null) {return RedirectToAction ( "Index "); } return View (modelo); } [HttpPost] public IActionResult Edit (int id, entrada de EmployeeEditViewModel) {var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); empleado var = sqlData.Get (id); if (employee! = null && ModelState.IsValid) {employee.Name = input.Name; context.SaveChanges openModal(); return RedirectToAction ( "Detalles ", nuevo {id = employee.Id}); } return View (empleado); } [HttpGet] Public ViewResult Create () {return View openModal(); } [HttpPost] crear IActionResult público (modelo EmployeeEditViewModel) {if (ModelState.IsValid) {var employee = new Employee openModal(); empleado.Nombre = modelo.Nombre; var context = new FirstAppDemoDbContext openModal(); SQLEmployeeData sqlData = new SQLEmployeeData (contexto); sqlData.Add (empleado); return RedirectToAction ( "Detalles ", nuevo {id = employee.Id}); } return View openModal(); }}
La página de inicio o el archivo Index.cshtml que muestra la lista de empleados tiene el atributo AllowAnonymous . Ahora iniciemos su aplicación.
Presione la tecla F12 que abrirá las herramientasdesarrollo . Ahora vaya a la pestaña Red .
Hay algunas cosas que queremos ver en las herramientas de desarrollo, para que podamos ver cómo funcionan las cosas . Cuando haga clic en el enlace Editar, verá una página en blanco.
Si mire las herramientas para desarrolladores, verá que el código de estado HTTP devuelto por el servidor era un código de estado 401 .
El código de estado 401 le dice al navegador que la solicitud no fue permitida porque no tenía credenciales válidas. Esto nos dice que el atributo Authorize está funcionando .
De manera similar, cuando haga clic en el enlace Crear en la página de inicio, verá el mismo error que se muestra en la siguiente captura de pantalla.
-
Aquí el problema es que el El usuario se queda en una página en blanco y, a menos que tenga abiertas las herramientas de desarrollo, es posible que no sepan que fueun problema de autenticación.
-
Aquí es donde el marco de identidad puede intervenir y ayudar.
-
El marco de identidad puede detectar cuando un elemento de la aplicación quiere devolver el código de estado 401 porque el usuario no está autorizado para acceder a él, y el El marco de identidad puede convertir esto en una página de inicio de sesión y permitir que el usuario supere este problema.
-
Veremos cómo funciona eso una vez que hayamos instalado y configurado el marco de identidad.
-
Pero por ahora, podemos ver que el atributo Autorizar está funcionando.
ASP.NET Core - Configuración de identidad
En este capítulo instalaremos y configuraremos el marco de identidad, este que solo requiere un poco de trabajo. Si va a Visual Studio y crea una nueva aplicación ASP.NET Core, y elige la plantilla de aplicación web completa con autenticacióndefinido en cuentas de usuario individuales, este nuevo proyecto incluirá todos los elementos del marco de identidad configurado para usted.
Empezamos con un proyecto vacío, ahora vamos a configurar el marco de identidad desde cero, que es una buena forma de conocer todas las partes del modelo de aplicación completa, ya que puede resultar confuso si no ha revisado todos los códigos en detalle.
Para comenzar, necesitaremos instalar la dependencia, que es Microsoft.AspNet.Identity . Haremos esto instalando Microsoft.AspNet.Identity.EntityFramework , luego implementando el marco de identidad que funciona con Entity Framework.
-
Si tomamos una dependencia en Identity.EntityFramework, el paquete incluye el paquete Identity.
-
Si crea sus propios almacenes de datos, solo puede trabajar con el Paquete de identidad.
-
Una vez que nuestro ddependencias instaladas, podemos crear una class de usuario cliente con toda la información que queremos almacenar sobre un usuario.
-
Para esta aplicación, vamos a heredar de una class proporcionada por el marco de identidad y esta class nos dará todos los elementos esenciales como la propiedad de nombre de usuario y un lugar para almacenar el contraseñas hash.
-
También necesitaremos modificar nuestra class FirstAppDemoDbContext para heredar f de la class IdentityDb de Identity Framework.
-
IdentityDb nos brinda todo lo que necesitamos para almacenar como información de usuario con Entity Framework. Una vez que hemos configurado una class de Usuario y un DBContext , necesitaremos configurar los servicios de identidad en la aplicación con el Método ConfigureServices de la class Startup.
-
Al igual que cuando tuvimos que agregarservicios Para admitir el marco MVC, el marco de identidad necesita servicios agregados a la aplicación para funcionar.
-
Estos servicios incluyen servicios como el servicio UserStore y el SignInManager .
-
Inyectaremos estos servicios en nuestro controlador para crear usuarios y emitir cookies en el momento apropiado.
-
Finalmente, durante el método de configuración de inicio, necesitaremos agregar el middleware de identidad.
-
Este middleware no solo ayudará a convertir las cookies en una identidad de usuario, sino que también garantizará que el usuario no le haga ver una página. vacío con una respuesta 401.
Ahora sigamos los pasos a continuación.
Paso 1 : necesitamos continuar agregando una dependencia en el marco de identidad. Agreguemos la dependencia Microsoft.AspNet.Identity.EntityFramework en el archivo project.json. Esto incluirá anosotros los otros paquetes de identidad necesarios que necesitamos.
{ "versión ": "1.0.0 - * ", "compilationOptions ": { "emitEntryPoint ": true}, " dependencias ": {" Microsoft.AspNet.Mvc ": " 6.0.0-rc1-final ", " Microsoft.AspNet.Diagnostics ": " 1.0.0-rc1-final ", "Microsoft.AspNet.IISPlatformHandler ": "1.0.0-rc1-final ", "Microsoft.AspNet.Server.Kestrel ": "1.0 .0-rc1-final ", "Microsoft.AspNet .StaticFiles ": " 1.0.0-rc1-final ", " EntityFramework.MicrosoftSqlServer ": " 7.0.0-rc1-final ", " EntityFramework.Commands ": " 7.0.0 -rc1-final ", " Microsoft.AspNet.Mvc.TagHelpers ": " 6.0.0-rc1-final ", " Microsoft.AspNet .Identity.EntityFramework ": " 3.0.0-rc1 -final "}, " comandos ": {" web ": " Microsoft.AspNet.Server.Kestrel ", " ef ": " EntityFramework.Commands "}, " frameworks ": {" dnx451 ": {}, " dnxcore50 ": {}}, " excluir ": [" wwwroot ", "node_modules "], " publishExclude ": [" **. usuario ", " **. vspscc "]}
Paso 2 - Guarde este archivo. Visual Studio restaura los paquetes y ahora podemos agregar nuestra class de usuario. Agreguemos la class de usuario haciendo clic con el botón directamente en la carpeta Modelos y seleccionando Agregar → Clase.
Llame a esta class de usuario y haga clic en el botón Agregar como en la captura de pantalla anterior En esta class puede agregar propiedades para contener toda la información que desee. desea almacenar en un usuario.
Paso 3 : Derivemos la class User de una class proporcionada por Identity Framework. Esta es la class IdentityUser que está en el espacio de nombres Identity.EntityFramework.
usando Microsoft.AspNet.Identity.EntityFramework; usando system; usando System.Collections.Generic ; usando System.Linq; usando System.Threading.Tasks; espacio de nombres FirstAppDemo.Models {Public class User: IdentityUser {}}
Paso 4 : ahora vayamos a IdentityUser, pase el cursor sobre este símbolo y presione F12 para ver la vista de datos de Visual Studio.
#region Assembly Microsoft.AspNet.Identity.EntityFramework, Version = 3.0.0.0, namespace Microsoft.AspNet.Identity.EntityFramework {public class IdentityUser: IdentityUser { public IdentityUser openModal(); public IdentityUser (cadena de nombre de usuario); }}
Paso 5 : puede ver que IdentityUser se deriva de IdentityUser a partir de la cadena. Puede cambiar el tipo de clave principal derivando de IdentityUser y especificando nuestro parámetro de tipo genérico. También puede almacenar cosas con una clave principal que idealmente es un valor entero.
Paso 6 - Ahora coloquemos el cursor en IdentityUser de la cadena y presionemos F12 nuevamente para ir a la vista de datos.
Puedentaining ver toda la información relativa a un usuario por defecto. La información incluye lo siguiente:
-
Campos que no usaremos en esta aplicación, pero que están disponibles.
-
El marco de identidad puede rastrear el número de intentos fallidos de inicio de sesión para un usuario en particular y puede bloquear esa cuenta durante un período de tiempo.
-
Campos para almacenar PasswordHash, PhoneNumber. Los dos campos importantes que usaremos son PasswordHash y UserName.
-
También usaremos implícitamente la clave principal y la propiedad de ID de un usuario. También puede utilizar esta propiedad si necesita buscar un usuario específico.
Paso 7 : ahora debemos asegurarnos de que el usuario esté incluido en nuestro DBContext. Entonces, abramos el FirstAppDemoDBContext quelo tenemos en nuestra aplicación, y en lugar de derivarlo directamente de DBContext, que es la class base incorporada de Entity Framework, ahora necesitamos derivarlo de IdentityDbContext.
usando Microsoft.AspNet.Identity.EntityFramework; utilizando Microsoft.Data.Entity; espacio de nombres FirstAppDemo.Models {class pública FirstAppDemoDbContext: IdentityDbContext {público DbSet Empleados {get; juntos; } override void OnConfiguring (DbContextOptionsBuilder optionsBuilder) {optionsBuilder.UseSqlServer ( "Data Source = (localdb) MSSQLLocalDB; Initial Catalog = FirstAppDemo; Integrated Security = True; Connect Timeout = 30; Encrypt = False; TrueServer; ApplicationFailnetWrite protegido = Falso "); }}}
Paso 8 : la class IdentityDbContext también está en el espacio de nombres Microsoft.AspNet.Identity.EntityFramework y podemos especificar el tipo de usuario que 'ella debeTienda. De esta manera, cualquier campo adicional que agreguemos a la class Usuario ingresará a la base de datos.
-
El IdentityDbContext proporciona DbSets adicionales, no solo para almacenar un usuario, sino también información sobre roles y reclamos de usuario.
-
Nuestra class de usuario ya está lista. Nuestra class FirstAppDemoDbContext está configurada para trabajar con el marco de identidad.
-
Ahora podemos ir a Configure y ConfigureServices para configurar el marco de identidad.
paso 9 : ahora comencemos con ConfigureServices . Además de nuestros servicios MVC y nuestros servicios de Entity Framework, necesitamos agregar nuestros servicios de identidad. Esto agregará todos los servicios en los que se basa el marco de identidad para hacer su trabajo.
public void ConfigureServices (IServiceCollection services) {services.AddMvc openModal(); services.AddEntityFramework () .AddSqlServer () .AddDbContext (opción => opción.UseSqlServer (Configuración [ "base de datos: conexión "])); services.AddIdentity () .AddEntityFrameworkStores openModal(); }
-
El método AddIdentity toma dos parámetros de tipo genérico: el tipo de entidad de usuario y el tipo de entidad de rol.
-
Los dos parámetros de tipo genérico son los tipos de nuestro usuario: la class de usuario que acabamos de crear y la class de rol con la que queremos trabajar. Ahora usaremos el IdentityRole incorporado. Esta class se encuentra en el espacio de nombres EntityFramework.
-
Cuando usamos Entity Framework con Identity, también necesitamos invocar un segundo método: AddEntityFrameworkStores.
-
El método AddEntityFrameworkStores confiadministrará servicios como UserStore, el servicio utilizado para crear usuarios y validar sus contraseñas.
Paso 10 - Las siguientes dos líneas son todo lo que necesitamos para configurar los servicios de la aplicación.
services.AddIdentity () .AddEntityFrameworkStores openModal();
Paso 11 : también necesitamos agregar el middleware. La ubicación donde insertamos el middleware es importante porque si insertamos el middleware demasiado tarde en la pip eline, nunca tendrá la oportunidad de procesar una solicitud.
Y si necesitamos verificaciones de autorización en nuestros controladores MVC, necesitamos tener el middleware Identity insertado antes del marco MVC para asegurarnos de que las cookies y también los errores 401 se manejen con éxito.
public void Configure (aplicación IApplicationBuilder) {app.UseIISPlatformHandler openModal(); app.UseDeveloperExceptionPage openModal(); app.UseRuntimeInfoPage openModal(); app.UseFileServer openModal(); app.UseIdentity openModal(); app.UseMvc (ConfigureRoute); app.Run ((context) => {var msg = Configuration [ "message "]; espera context.Response.WriteAsync (msg);}); }
Paso 12 : el lugar donde insertamos el middleware es donde agregaremos el middleware de identidad. La siguiente es la implementación completa del archivo Startup.cs.
usando Microsoft.AspNet.Builder; utilizando Microsoft.AspNet.Hosting; utilizando Microsoft.AspNet.Http; utilizando Microsoft.Extensions.DependencyInjection; utilizando Microsoft.Extensions.Configuration; utilizando FirstAppDemo.Services; utilizando Microsoft.AspNet.Routing; usando el sistema; utilizando FirstAppDemo.Entities; utilizando Microsoft.Data.Entity; utilizando FirstAppDemo.Models; utilizando Microsoft.AspNet.Identity.EntityFramework; espacio de nombres FirstAppDemo {public cLass Startup {Public Startup () {var builder = new ConfigurationBuilder () .AddJsonFile ( "AppSettings.json "); Configuración = constructor.Build openModal(); } Configuración de IConfiguration pública {get; juntos; } // Este método es llamado por el tiempo de ejecución. // Utilice este método para agregar servicios al contenedor. // Para obtener más información sobre la configuración de su aplicación, // visite http: //go.microsoft.com/fw/? LinkID "= 398940 public void ConfigureServices (IServiceCollection services) {services.AddMvc openModal(); services.AddEntityFramework () .AddSqlServer () .AddDbContext (option => option.UseSqlServer (Configuration [ "database: connection "])); services.AddIdentity () .AddEntityFra meworkStores openModal();} // El tiempo de ejecución llama a este método. // Utilice este método para configurar la canalización de solicitudes HTTP public void Configure (aplicación IApplicationBuilder) {app.UseIISPlatformHandler openModal(); app.UseDeveloperExceptionPage openModal(); app.UseRuntimeInfoPage openModal(); app.UseFileServer openModal(); app.UseIdentity openModal(); app.UseMvc (ConfigureRoute); app.Run ((context) => {var msg = Configuration [ "message "]; espera context.Response.WriteAsync (msg);}); } private void ConfigureRoute (IRouteBuilder routeBuilder) {// Inicio / Index routeBuilder.MapRoute ( "Default ", "{controller = Home} / {action = Index} / {id?} "); } // Punto de entrada de la aplicación. public static void Main (string args) => WebApplication.Run (args); }}
Paso 13 : ahora avancemos construyendo la aplicación. En el siguiente capítulo, necesitamos agregar otra migración de Entity Framework para asegurarnos de que tenemos el esquema de identidad en nuestra base de datos de SQL Server.
ASP.NET Core - Migraciones de identidad
En este capítulo, analizaremos la migración de identidad. En ASP.NET Core MVC, la autenticación y 'La identidad se configura en el archivo Startup.cs.
public void ConfigureServices (servicios IServiceCollection) {services.AddMvc openModal(); services.AddEntityFramework () .AddSqlServer () .AddDbContext opción. UseSqlServer (Configuración [ "base de datos: conexión "])); services.AddIdentity () .AddEntityFrameworkStores openModal(); }
Siempre que realice un cambio en cualquiera de sus classs de entidad o realice un cambio en su class derivada de DBContext, es probable que deba crear una nueva migración para aplicar a la base de datos y sincronice el esquema con lo que está en su código.
Este es el caso en nuestra aplicación, ya que ahora derivamos nuestra class FirstAppDemoDbContext de la class IdentityDbContext, y contiene sus propios DbSets, y también creará un esquema para almacenar todosinformación sobre las entidades que gestiona.
usando Microsoft.AspNet.Identity.EntityFramework; utilizando Microsoft.Data.Entity; espacio de nombres FirstAppDemo.Models {FirstAppDemoDbContext class pública: IdentityDbContext {DbSet público Empleados {get; juntos; } override void OnConfiguring (DbContextOptionsBuilder optionsBuilder) {optionsBuilder.UseSqlServer ( "Data Source = (localdb) MSSQLLocalDB; Initial Catalog = FirstAppDemo; Integrated Security = True; Connect Timeout = 30; Encrypt = False; TrueServer; ApplicationFailnetWrite protegido = Falso "); }}}
Ahora abramos el símbolo del sistema y verifiquemos que estamos en la ubicación donde está el archivo project.json para nuestro proyecto.
También podemos obtener comandos de Entity Framework escribiendo dnx ef .
Nuestro archivo project.json tiene una sección que asigna esta palabra clave "ef" a los comandos EntityFramework.Commands.
"orders ": { "web ": "Microsoft.AspNet.Server.Kestrel ", "ef ": "EntityFramework. Comandos "}
Podemos agregar una migración desde aquí. También necesitamos darle un nombre a la migración. Usemos v2 para la versión 2 y presione enter.
Una vez que se complete la migración, tendrá un archivo v2 en su carpeta de migraciones.
Ahora queremos aplicar esta migración a nuestra base de datos ejecutando el comando "dnx ef database update" .
Entity Framework verá que es necesario aplicar una migración y ejecutará esta migración.
Si ingresa al Explorador de objetos de SQL Server, verá la tabla de empleados que creamos anteriormente. También verá tablas adicionales que necesitan almacenar usuarios, reclamaciones, roles y tablas de mapeo que corresponden a los usuarios con roles específicos.
Todas estas tablas están vinculadas aentidades proporcionadas por el marco de identidad.
Echemos un vistazo a la tabla de usuarios .
Ahora puede ver que las columnas de la tabla AspNetUsers incluyen columnas para almacenar todas las propiedades que vimos en el usuario de identidad que heredamos, y sus campos como Nombre de usuario y PasswordHash. Entonces, usó algunos de los servicios de 'Identidad incorporada, ya que también contienen la capacidad de crear un usuario y validar la contraseña de un usuario.
ASP.NET Core - Registro de usuario
En En este capítulo discutiremos el registro de usuarios. Ahora tenemos una base de datos en funcionamiento y es hora de comenzar a agregar algunas funcionalidades a la aplicación. También hemos configurado nuestra aplicación y tenemos un esquema básico Ahora volvamos a la página de inicio de la aplicación.
OuvAbra las herramientas de desarrollo presionando F12 y luego haga clic en el enlace Modificar. Anteriormente, cuando hacíamos clic en el enlace Editar, el marco MVC detectaba la presencia del atributo Autorizar y devolvía un código de estado 401 porque el usuario no había iniciado sesión.
Ahora verá que recibimos un mensaje en la pantalla del archivo de configuración.
Ahora vayamos a las herramientas de desarrollo.
-
Verá que el navegador ha solicitado la página de edición y el marco MVC ha decidido que el usuario no puede ver este recurso.
-
Entonces, en algún lugar del marco MVC, se generó un código de estado 401.
-
Ahora tenemos el middleware de Identity instalado, que examina este código de estado 401 que se enviará al usuario y lo reemplaza con un código de estado 302, que es un código de estado. estado de redireccionamiento.
-
El marco de identidad sabe que el usuariosateur tendrá que intentar iniciar sesión antes de poder acceder a este recurso.
-
El marco de identidad nos dirigió a esta URL, como podemos ver en la barra de direcciones - / Cuenta / Iniciar sesión.
-
Este es un punto final configurable con el marco de identidad, dentro del inicio cuando registra estos servicios y middleware. Hay diferentes opciones que puede configurar y una de las opciones es cambiar la URL de inicio de sesión.
-
De forma predeterminada, la URL será / Cuenta / Iniciar sesión. Actualmente no tenemos un controlador de cuenta, por lo que al final del día queremos crear un controlador de cuenta y permitir que un usuario inicie sesión.
-
Pero antes de que los usuarios puedan iniciar sesión, deberán registrarse en el sitio y registrar sus nombres de usuario y contraseñas.
-
Las funciones de inicio de sesión y registro pueden hacerparte de un controlador de cuenta.
Ahora sigamos y agreguemos una nueva class en la carpeta Controllers, y llamémosla AccountController. Derivaremos esto de la class Controller base del marco MVC.
usando Microsoft.AspNet.Mvc; usando el sistema; utilizando System.Collections.Generic; using System.ComponentMo del.DataAnnotations; utilizando System.Linq; usando System.Threading.Tasks; espacio de nombres FirstAppDemo.Controllers {public class AccountController: Controller {}}
-
Ahora vamos a tener que configurar una función que permita a un usuario s ' registrarse en este sitio.
-
Se parecerá mucho a un formulario de edición.
-
Cuando el usuario quiera registrarse, primero le mostraremos un formulario que le permitirá completar la información requerida. Luego pueden descargar este formulario sen el sitio.
-
Esta información se guarda en la base de datos.
Ahora vamos a crear la acción que devolverá una vista cuando vayamos a /account/register.
Public Class AccountController: Controller {[HttpGet] Public ViewResult Register () {return View openModal(); }}
No necesitamos buscar nada, el usuario proporcionará toda la información que necesitemos. Antes de crear el ViewModel para esta vista, debemos decidir qué información mostrará la vista. También debemos decidir qué información necesitaremos recibir del usuario.
Creemos un modelo de vista para este escenario agregando una nueva class en el archivo AccountController.cs y llamándolo RegisterViewModel.
Creemos algunas propiedades que contendrán el nombre de usuario, la contraseña y también el usuario ConfirmPassword en el tescribiendo dos veces y asegurándose de que las dos contraseñas coincidan como se muestra en el siguiente programa.
public class RegisterViewModel {[Requerido, MaxLength (256)] cadena pública Username {get; juntos; } [Requerido, DataType (DataType.Password)] cadena pública Contraseña {get; juntos; } [DataType (DataType.Password), Compare (nombre de (Contraseña))] cadena pública ConfirmPassword {get; juntos; }} En la class anterior, puede ver algunas anotaciones que pueden ayudarnos a validar este modelo. Aquí se requiere el nombre de usuario y, si observa el esquema de la base de datos, la columna que debe contener un nombre de usuario tiene 256 caracteres.
También aplicaremos un atributo MaxLength aquí.
Se requerirá una contraseña y cuando hacemos una entrada para esta contraseña, queremos que el tipo de entrada sea Escriba contraseña afen que los personajes no aparecen en la pantalla.
La Confirmar contraseña también será la contraseña de tipo de datos, luego habrá un atributo de comparación adicional. Compararemos el campo ConfirmPassword con esta otra propiedad que podemos especificar, que es el campo Password.
Ahora creemos la vista que necesitamos. Necesitaremos agregar una nueva carpeta a las vistas y llamarla Cuenta, por lo que todas las vistas vinculadas al AccountController se agregarán a esta carpeta.
Ahora haga clic derecho en la carpeta Cuenta y seleccione Agregar → Nuevo elemento.
En el panel central, seleccione la página de visualización MVC y asígnele el nombre Registrar .cshtml, luego haga clic en el botón Agregar.
Elimine todos los códigos existentes del archivo Register.cshtml y agregue el siguiente código.
@model RegisterViewModel @ {ViewBag.Title = "Registrarse}
Registrarse
-
Ahora puede ver que hemos especificado el modelo como el RegisterViewModel que acabamos de crear.
-
También vamos a establecer el título de esta página usando ViewBag y queremos que el título sea Registro.
-
También necesitamos crear un formulario que contenga los campos Nombre de usuario, Contraseña y Confirmar contraseña.
-
También hemos incluido un
-
Podemos mostrar todos los errores en el área de resumen, o podemosdigamos ValidationSummary.ModelOnly y los únicos errores que aparecerán al validar el modelo dentro del resumen serán los errores de validación asociados con el modelo y no una propiedad específica de ese modelo.
-
En otras palabras, si los usuarios no ingresan su nombre de usuario, pero el nombre de usuario es obligatorio, habrá un error. validación para esa propiedad específica.
-
Pero también puede generar errores de modelo que no están asociados con una propiedad específica y que aparecerán en este ValidationSummary.
-
En una etiqueta tenemos etiquetas y entradas para todos los diferentes campos que tenemos en nuestro ViewModel.
-
Necesitamos una etiqueta para el nombre de usuario, una entrada para el nombre de usuario y también mensajes de validación para el nombre de usuario. 'usuario.
-
Los otros dos son profesionalesLos valores que debemos ingresar por parte del usuario son los mismos y tendrán una etiqueta y una entrada y un alcance para la contraseña y una etiqueta y una entrada y un alcance para ConfirmPassword.
-
No necesitamos especificar los tipos de entrada para la contraseña y la contraseña de confirmación, porque asp para el asistente de etiquetas se asegurará de establecer este tipo de entrada como contraseña para nosotros.
-
Al final debemos tener el botón que dice Registrarse . Cuando el usuario haga clic en este botón, reenviaremos el formulario al controlador.
En AccountController, también necesitamos implementar un método de acción HttpPost Register. Regresemos al AccountController y agreguemos la siguiente acción de registro de la siguiente manera:
[HttpPost] public IActionResult Register (modelo RegisterViewModel) {}
Este método la acción devolverá un IActionResult. Esto recibirá un RegisterViewModel. Ahora tenemos que interactuar con el marco de identidad para asegurarnos de que el usuario es válido, decirle al marco de identidad que cree este usuario y luego, como acaban de crear la cuenta, inicie sesión. Veremos la implementación de todos estos pasos en el próximo capítulo.
ASP.NET Core - Crear usuario
En este capítulo discutiremos cómo crear un usuario. Para continuar, necesitamos interactuar con el marco de identidad para asegurarnos de que el usuario sea válido, luego crear este usuario, luego continuar e iniciar sesión.
-
Hay dos servicios básicos del marco de identidad, uno es el UserManager y el otro es el SignInManager.
-
Necesitamos inyectar estos dos servicios en nuestro controlador. Con esto podemos llamar a las API apropiadas cuando necesitemos crear un usuario.ro iniciar sesión como usuario.
-
Agreguemos variables privadas para SignInManager y UserManager, luego agreguemos un constructor en su AccountController, que tomará dos parámetros de UserManager de tipo User y un SignInManager de tipo User.
private SignInManager _signManager; UserManager privado _userManager; AccountController public (UserManager userManager, SignInManager signManager) {_userManager = userManager; _signManager = signManager; }
-
Vamos a continuar con el método de acción POST de AccountController y una de las primeras comprobaciones que siempre debemos hacer dentro del La acción posterior es verificar si nuestro ModelState es válido.
-
Si ModelState es válido, entonces sabemos que el usuario nos dio un nombre de usuario y contraseña y confirmó la contraseña; si no, tenemos que pedirles que foComplete la información correcta.
-
Aquí está la implementación de la acción Guardar.
[HttpPost] Public Task Registro (modelo RegisterViewModel) {if (ModelState.IsValid) {var user = new User { Nombre de usuario = modelo.Nombre de usuario}; var resultado = esperar _userManager.CreateAsync (usuario, modelo.Password); if (result.Succeeded) {espera _signManager.SignInAsync (usuario, falso); return RedirectToAction ( "Índice ", "Inicio "); } else {foreach (var error en result.Errors) {ModelState.AddModelError ( "", error.Deion); }}} return View openModal(); }
-
Si nuestro ModelState es válido, necesitamos hablar con el marco de identidad. También necesitamos crear una nueva instancia de nuestra entidad Usuario y copiar nuestra entrada model.Username en la propiedad UserName de la entidad User.
-
Pero no vamos a copiar la contraseña porque no hay lugar para almacenarVerifique la contraseña en texto sin formato en la entidad Usuario. En su lugar, pasaremos la contraseña directamente al marco de identidad, que hará un hash de la contraseña.
-
Así que tenemos un userManager. Cree un método Async en el que necesitemos pasar el nombre de usuario, para que podamos guardar la contraseña de ese usuario.
-
Este método Async devuelve un resultado que nos dice si la instancia tuvo éxito o falló y si falló, esto nos dará algunas de las posibles razones de su falla.
-
Si el resultado es exitoso, podemos conectar al usuario que acaba de crear una cuenta y luego pedirle al SignInManager que firme a este usuario. Ahora redirija al usuario a la página de inicio y ahora estará autenticado.
-
Si el resultado no fue exitoso, deberíamos intentar decirle al usuario por qué, y el resultado que viene de UserManager tiene unaLa colección de errores que podemos iterar y agregar estos errores en ModelState. Estos errores estarán disponibles en la vista para los asistentes de etiquetas, como los asistentes de etiquetas de validación, para mostrar información sobre la página.
-
En ModelState.AddModelError, podemos proporcionar una clave para asociar un error con un campo específico. También usaremos una cadena vacía y agregaremos la deion del error que se proporcionó.
Hagamos una copia de seguridad de todos los archivos, ejecutemos la aplicación y vayamos a / account / registry .
Ingresemos un nombre de usuario y contraseña de 5 caracteres muy simples.
Ahora haga clic en el botón Guardar.
Predeterminado , el marco de identidad intenta hacer cumplir ciertas reglas en torno a las contraseñas.
Las contraseñas deben tener al menos 6 caracteres, un carácter debe estar en minúsculas, el otro en mayúsculas y debe ser un carácter no numérico.
La rLa razón por la que estos errores aparecen aquí es porque tenemos una suma de confirmación de Mary en la página que detecta los errores que regresan del resultado de userManager.CreateAsync .
Ahora que sabemos un poco más sobre las reglas de las contraseñas, intentemos crear una contraseña lo suficientemente compleja y haga clic en registrarse.
Ahora verá la página de inicio. Esto significa que la operación funcionó . Ahora pasemos al Explorador de objetos de SQL Server.
Haga clic con el botón derecho en la tabla dbo.AspNetUsers y seleccione Mostrar datos .
Ahora puede ver que el usuario se creó correctamente y también puede ver un nuevo registro en la tabla Usuarios. También puede ver un valor de contraseña con hash así como un nombre de usuario y este es el nombre de usuario que registramos con mark.upston .
ASP.NET Core: inicio de sesión y diciembreonnexion
En este capítulo, tenemos la funcionalidad de conexión y desconexión. La desconexión es bastante sencilla de implementar en comparación con la conexión. Continuemos con la vista Diseño porque queremos crear una interfaz de usuario con enlaces. Esto permitirá que un usuario que haya iniciado sesión cierre la sesión y muestre también el nombre de usuario.
< name = "viewport " content = "width = device-width " /> @ ViewBag.Title @ DateTime.Now @RenderBody ()
-
Para un usuario anónimo, mostraremos un enlace de inicio de sesión.
-
Toda la información que necesita para crear esta interfaz de usuario está disponible en el contexto de la vista Razor.
-
Primero, agreguemos el espacio de nombres System .Security.Claims en su vista de diseño.
@usando System.Security.Claims < name = "viewport " content = "width = device-width " /> @ ViewBag.Title @if (User.IsSignedIn ()) {@ User.GetUserName ()} el { Iniciar sesión Registrarse } @ DateTime.Now @RenderBody ()
-
Hay una propiedad de usuario que está disponible en cada vista de Razor y queremos crear una interfaz de usuario que mostrará el nombre del usuario que inició sesión. Un método de extensión IsSignedIn también está disponible aquí.
-
Podemos invocar este método y si devuelve verdadero, aquí es donde podemos colocar el marcado, mostrar el nombre de usuario, mostrar un botón de cierre de sesión.
-
Ahora, si el usuario ha iniciado sesión, podemos mostrar el nombre de usuario del usuario utilizando el método auxiliar GetUserName .
-
Necesitaremos crear un botón de cierre de sesión en un formulario, que se publicará en el servidor web. Esto debe hacerse ya que creará algunas condiciones desagradables, si permite un simple GET REQUEST para permitir que un usuario salga.
-
Forzaremos que esto sea un mensaje, y cuando el usuario envíe este formulario, todo lo que tenemos que hacer es presionar la acción de cierre de sesión. , que implementaremos a través del AccountController, y para desconectar al usuario.
-
Si el usuario no ha iniciado sesión y tenemos un usuario anónimo, entonces debemos mostrar un enlace que irá al AccountController, en particular a la acción de inicio de sesión, y puede mostrar el texto Iniciar sesión.
-
También necesitamos agregar un enlace para que los nuevos usuarios se registren y vayan directamente a la página de registro.
Ahora vayamos a AccountController y primero implemente la acción de cierre de sesión como en el siguiente programa.
[HttpPost] Tarea pública Logout () {await _signManager.SignOutAsync openModal(); return RedirectToAction ( "Índice ", "Inicio "); }
-
Esta acción solo responde a HttpPost. Es una acción maravillosa. Tendremos que llamar a otro método hrone en el marco de identidad.
-
Podemos devolver una tarea desde IActionResult y la acción se llama Logout.
-
Todo lo que tenemos que hacer para cerrar la sesión es esperar el método SignOutAsync de SignInManager .
-
El contexto del usuario ha cambiado ahora; ahora tenemos un usuario anónimo. La vista será redirigida a la página de inicio y regresaremos a la lista de empleados.
Ahora continuemos y construyamos nuestra función de inicio de sesión. Aquí necesitaremos un par dections, uno que responde a una solicitud HttpGet y muestra el formulario que podemos usar para iniciar sesión, y uno que responde a una solicitud HttpPost.
Para empezar, necesitaremos un nuevo ViewModel para extraer los datos de conexión porque la conexión es muy diferente a la grabación. Entonces, agreguemos una nueva class y llamémosla LoginViewModel .
class pública LoginViewModel {cadena pública Nombre de usuario {get; juntos; } [DataType (DataType.Password)] cadena pública Contraseña {get; juntos; } [Display (Name = "Recordarme ")] public bool RememberMe {get; juntos; } cadena pública ReturnUrl {get; juntos; }}
-
Cuando los usuarios inician sesión, deben proporcionar información como nombre de usuario, contraseña.
-
La tercera pieza de información debe ser la interfaz de usuario de inicio de sesión. Estos van acompañados de unLa pequeña casilla de verificación que dice "Quieres recordarme". Esta es la elección entre si queremos una cookie de sesión o queremos una cookie más permanente.
-
Para habilitar esta funcionalidad, agregamos una propiedad booleana RememberMe y usamos una anotación de visualización. Ahora, cuando creamos una etiqueta, el texto Recordarme se muestra con un espacio.
-
La última información que realmente queremos como parte de este ViewModel es tener una propiedad que almacene ReturnUrl.
Ahora agreguemos la acción de inicio de sesión que responderá a la solicitud Get como se muestra en el siguiente programa.
[HttpGet] Inicio de sesión de IActionResult público (string returnUrl = "") {var model = new LoginViewModel {ReturnUrl = returnUrl}; Vista posterior (modelo); }
Ahora tendremos una nueva vista agregando una nueva página de vista MVC en la carpeta Vistas → Cuenta .
En el panel central, seleccione la página de visualización MVC y asígnele el nombre Login.cshtml, luego haga clic en el botón Agregar. Agreguemos el siguiente código al archivo Login.cshtml.
@model LoginViewModel @ {ViewBag.Title = " Iniciar sesión}
Iniciar sesión
-
En este vista de inicio de sesión, establecemos el título de la página en Iniciar sesión, luego tenemos un formulario que podrávinculado a la acción AccountLogin .
-
Necesitamos usar un asistente de etiquetas, asp-route-returnurl , para asegurarnos de que ReturnUrl esté en la URL donde devoluciones de formulario.
-
Necesitamos enviar esta ReturnUrl al servidor para que, si el usuario se conecta correctamente, podamos enviarla a donde estaba intentando ir. .
-
Todo lo que agregue después de asp-route-, id o returnurl, lo que sea que tenga allí, irá en algún lugar de la solicitud, ya sea en la ruta de 'URL, o como parámetro de cadena de consulta.
-
Tenemos nuestro ValidationSummary y las entradas para Nombre de usuario, Contraseña y Recuérdame, luego tenemos un botón Enviar.
` AccountController , e implemente la acción Publicar. Esta acción que responde a HttpPost. Será un método Async porque necesitaremos llamar al marco de identidad y devolver une tarea o IActionResult.
[HttpPost] public Task Iniciar sesión (modelo LoginViewModel) {if (ModelState.IsValid) {var result = wait _signManager.PasswordSignInAsync (model.Username, model. Contraseña, modelo.RememberMe, falso); if (result.Succeeded) {if (! string.IsNullOrEmpty (model.ReturnUrl) && Url.IsLocalUrl (model.ReturnUrl)) {return Redirect (model.ReturnUrl); } else {return RedirectToAction ( "Índice ", "Inicio "); }}} ModelState.AddModelError ( "", "Intento de conexión no válido "); Vista posterior (modelo); }
-
Llamamos a este inicio de sesión, y ahora esperamos recibir un LoginViewModel.
-
Necesitamos comprobar si ModelState es válido. Si es válido, conéctese al usuario llamando a una API en SignInManager.
-
El método PasswordSignInAsync devolverá un resultado y si el resultado es exitoso, sabemos que el usuario ha iniciado sesión.con éxito.
-
También tenemos una URL de retorno. Si esta es una URL local válida, se nos redirigirá a la URL de retorno.
-
Si el usuario acaba de iniciar sesión y no tiene un lugar específico al que ir, redirigiremos al usuario a la acción Índice de HomeController.
-
Podríamos estar en una situación en la que el usuario proporcione una contraseña o un nombre de usuario no válidos. También necesitamos agregar un error de plantilla que pregunte si hay un intento de inicio de sesión no válido. Ayuda al usuario a saber si algo anda mal.
Ahora guardemos todo y ejecutemos la aplicación.
Ahora tenemos enlaces de conexión e inion. Hagamos clic en el enlace de conexión.
Conectemos con el 'usuario que creamos en el capítulo anterior especificando el Nombre de usuario y la Contraseña y marque la casilla Recuérdame .
Cuando hace clic en el botón Conectar, el navegador le pregunta si desea guardar su contraseña para el host local. Hagamos clic en el botón Sí.
Ahora cerramos la sesión haciendo clic en el botón Cerrar sesión.
Como 'usuario anónimo, intentemos editar los detalles del empleado.
Ahora puede ver que hemos sido redirigidos a la vista de inicio de sesión .
Permítanos iniciar sesión con su nombre de usuario y contraseña y marque la casilla de verificación Recordarme.
Ahora , haga clic en el botón Conexión.
Ahora puede ver que estamos dirigidos a la URL que queremos cambiar. De hecho, hemos manejado la URL de retorno de manera apropiada .
