Crear una aplicación de base de datos de película en 15 minutos con ASP.NET MVC (C#)
por Stephen Walther
Stephen Walther crea una aplicación entera de ASP.NET MVC controlada por base de datos de principio a fin. Este tutorial es una excelente introducción a las personas que no están familiarizadas con el marco de MVC de ASP.NET y que quieren tener una idea del proceso de creación de una aplicación ASP.NET MVC.
El propósito de este tutorial es darle una idea de "cómo es" crear una aplicación de ASP.NET MVC. En este tutorial, desarrollo rápidamente una aplicación completa de ASP.NET MVC desde el principio hasta el final. Ya les he mostrado cómo crear una aplicación sencilla controlada por base de datos que ilustra cómo puede enumerar, crear y editar registros de base de datos.
Para simplificar el proceso de crear la aplicación, aprovecharemos las características de andamiaje de Visual Studio 2008. Dejaremos que Visual Studio genere el código y el contenido iniciales de nuestros controladores, modelos y vistas.
Si ha trabajado con Active Server Pages o ASP.NET, ASP.NET MVC le resultará muy familiar. Las vistas de ASP.NET MVC son muy parecidas a las páginas de una aplicación de Active Server Pages. Además, al igual que una aplicación tradicional de ASP.NET Web Forms, ASP.NET MVC proporciona acceso completo al amplio conjunto de lenguajes y clases proporcionados por .NET Framework.
Espero que este tutorial le dé una idea de cómo la experiencia de crear una aplicación de ASP.NET MVC es tanto parecida como diferente a la de crear una aplicación de Active Server Pages o ASP.NET Web Forms.
Introducción a la aplicación de base de datos de películas
Dado que nuestro objetivo es simplificar las cosas, crearemos una aplicación de base de datos de películas muy sencilla. Nuestra sencilla aplicación de base de datos de películas nos permitirá hacer tres cosas:
- Enumerar un conjunto de registros de base de datos de películas
- Crear un nuevo registro de base de datos de películas
- Editar un registro de base de datos de películas existente
De nuevo, dado que queremos simplificar las cosas, usaremos el número mínimo de características del marco ASP.NET MVC necesarias para crear la aplicación. Por ejemplo, no usaremos el desarrollo controlado por pruebas.
Para crear nuestra aplicación, es necesario realizar cada uno de los pasos siguientes:
- Crear el proyecto de aplicación web ASP.NET MVC
- Creación de la base de datos
- Crear el modelo de base de datos
- Crear el controlador de ASP.NET MVC
- Crear las vistas de ASP.NET MVC
Pasos preliminares
Necesitará Visual Studio 2008 o Visual Web Developer 2008 Express para crear una aplicación ASP.NET MVC. También debe descargar el marco ASP.NET MVC.
Si no tiene Visual Studio 2008, puede descargar una versión de prueba de 90 días en este sitio web:
https://msdn.microsoft.com/vs2008/products/cc268305.aspx
Como alternativa, puede crear aplicaciones ASP.NET MVC con Visual Web Developer 2008 Express. Si decide usar Visual Web Developer Express, debe tener instalado Service Pack 1. Puede descargar Visual Web Developer 2008 Express con Service Pack 1 en este sitio web:
Después de instalar Visual Studio 2008 o Visual Web Developer 2008, debe instalar el marco ASP.NET MVC. Puede descargarlo en el siguiente sitio web:
Nota:
En lugar de descargar el marco ASP.NET y el marco ASP.NET MVC por separado, puede usar el Instalador de plataforma web. El Instalador de plataforma web es una aplicación que le permite administrar fácilmente las aplicaciones instaladas en su equipo:
Creación de un proyecto de aplicación web de ASP.NET MVC
Para comenzar, crearemos un nuevo proyecto de aplicación web de ASP.NET MVC en Visual Studio 2008. Seleccione la opción de menú Archivo, Nuevo proyecto y verá el cuadro de diálogo Nuevo proyecto de la figura 1. Seleccione C# como lenguaje de programación y seleccione la plantilla de proyecto Aplicación web ASP.NET MVC. Asigne al proyecto el nombre MovieApp y haga clic en el botón Aceptar.
Figura 01: Cuadro de diálogo Nuevo proyecto (haga clic para ver la imagen a tamaño completo)
Asegúrese de seleccionar .NET Framework 3.5 en la lista desplegable de la parte superior del cuadro de diálogo Nuevo proyecto o la plantilla de proyecto Aplicación web ASP.NET MVC no aparecerá.
Cada vez que cree un nuevo proyecto de aplicación web MVC, Visual Studio le pedirá que cree un proyecto de prueba unitaria diferente. Aparece el cuadro de diálogo de la figura 2. Dado que no vamos a crear pruebas en este tutorial por limitaciones de tiempo (y, sí, deberíamos sentirnos algo culpable por ello), seleccione la opción No y haga clic en el botón Aceptar.
Nota:
Visual Web Developer no admite proyectos de prueba.
Figura 02: Cuadro de diálogo Crear proyecto de prueba unitaria (haga clic para ver la imagende tamaño completo)
Una aplicación ASP.NET MVC tiene un conjunto estándar de carpetas: Models, Views y Controllers. Puede ver este conjunto estándar de carpetas en la ventana del Explorador de soluciones. Tendremos que agregar archivos a cada una de las carpetas Models, Views y Controllers para crear nuestra aplicación de base de datos de películas.
Al crear una nueva aplicación MVC con Visual Studio, obtendrá una aplicación de ejemplo. Dado que queremos empezar desde cero, es necesario eliminar el contenido de esta aplicación de ejemplo. Para ello, debe eliminar el siguiente archivo y la carpeta siguiente:
- Controllers\HomeController.cs
- Views\Home
Creación de la base de datos
Necesitamos crear una base de datos para almacenar los registros de la base de datos de películas. Afortunadamente, Visual Studio incluye una base de datos gratuita denominada SQL Server Express. Para crear la base de datos, siga estos pasos:
- Haga clic con el botón derecho en la carpeta App_Data de la ventana del Explorador de soluciones y seleccione la opción de menú Agregar, Nuevo elemento.
- Seleccione la categoría Datos y seleccione la plantilla Base de datos SQL Server (vea la figura 3).
- Asigne a la nueva base de datos el nombre MoviesDB.mdf y haga clic en el botón Agregar.
Después de crear la base de datos, puede conectarse a ella haciendo doble clic en el archivo MoviesDB.mdf ubicado en la carpeta App_Data. Al hacer doble clic en el archivo MoviesDB.mdf, se abre la ventana del Explorador de servidores.
Nota:
La ventana del Explorador de servidores se llama Explorador de bases de datos en el caso de Visual Web Developer.
Figura 03: Creación de una base de datos de Microsoft SQL Server (haga clic para ver la imagen a tamaño completo)
A continuación, es necesario crear una nueva tabla de base de datos. En la ventana del Explorador de servidores, haga clic con el botón derecho en la carpeta Tablas y seleccione la opción de menú Agregar nueva tabla. Al seleccionar esta opción de menú, se abre el diseñador de tablas de base de datos. Cree las siguientes columnas de base de datos:
| Nombre de la columna | Tipo de datos | Permitir valores NULL |
|---|---|---|
| Identificador | Int | False |
| Título | Nvarchar(100) | False |
| Director | Nvarchar(100) | False |
| DateReleased | DateTime | False |
La primera columna, la columna Id, tiene dos propiedades especiales. En primer lugar, debe marcar la columna Id como columna de clave principal. Después de seleccionar la columna Id, haga clic en el botón Establecer clave principal (es el icono que tiene un aspecto similar a una llave). En segundo lugar, debe marcar la columna Id como una columna Identity. En la ventana Propiedades de columna, desplácese hacia abajo hasta la sección Especificación de identidad y expándala. Cambie la propiedad Is Identity al valor Sí. Cuando haya terminado, la tabla debe parecerse a la de la figura 4.
Figura 04: La tabla de base de datos Movies (haga clic para ver la imagen a tamaño completo)
El último paso es guardar la nueva tabla. Haga clic en el botón Guardar (el icono del disquete) y asigne a la nueva tabla el nombre Movies.
Una vez finalizada la creación de la tabla, agregue a esta algunos registros. Haga clic con el botón derecho en la tabla Movies en la ventana del Explorador de servidores y seleccione la opción de menú Mostrar datos de tabla. Escriba una lista de sus películas favoritas (vea la figura 5).
Figura 05: Introducir registros de películas (haga clic para ver la imagen a tamaño completo)
Creación del modelo
A continuación, es necesario crear un conjunto de clases para representar nuestra base de datos. Es necesario crear un modelo de base de datos. Usaremos Microsoft Entity Framework para generar automáticamente las clases de nuestro modelo de base de datos.
Nota:
El marco ASP.NET MVC no está vinculado a Microsoft Entity Framework. Puede crear las clases de modelo de base de datos usando diversas herramientas de asignación relacional de objetos (OR/M), como LINQ to SQL, Subsonic y NHibernate.
Siga estos pasos para iniciar el Asistente para Entity Data Model:
- Haga clic con el botón derecho en la carpeta Models en la ventana del Explorador de soluciones y seleccione la opción de menú Agregar, Nuevo elemento.
- Seleccione la categoría Datos y seleccione la plantilla Entity Data Model de ADO.NET.
- Asigne al modelo de datos el nombre MoviesDBModel.edmx y haga clic en el botón Agregar.
Después de hacer clic en el botón Agregar, aparece el Asistente de Entity Data Model (vea la figura 6). Siga estos pasos para completar el asistente:
- En el paso Elegir contenido del modelo, seleccione la opción Generar a partir de base de datos.
- En el paso Elegir la conexión de datos, use la conexión de datos MoviesDB.mdf y el nombre MoviesDBEntities para la configuración de conexión. Haga clic en el botón Next (Siguiente).
- En el paso Elegir los objetos de base de datos, expanda el nodo Tablas, seleccione la tabla Películas. Escriba el espacio de nombres MovieApp.Models y haga clic en el botón Finalizar.
Figura 06: Generación de un modelo de base de datos con el Asistente de Entity Data Model (haga clic para ver la imagen a tamaño completo)
Después de completar el Asistente de Entity Data Model, se abre el Diseñador de Entity Data Model. El Diseñador debería mostrar la tabla de base de datos Movies (vea la figura 7).
Figura 07: Diseñador de Entity Data Model (haga clic para ver la imagen a tamaño completo)
Necesitamos realizar un cambio antes de continuar. El Asistente para Entity Data genera una clase de modelo denominada Movies que representa la tabla de base de datos Películas. Dado que usaremos la clase Movies para representar una película determinada, es necesario modificar el nombre de la clase para que sea Movie en lugar de Movies (singular en lugar de plural).
Haga doble clic en el nombre de la clase en la superficie del diseñador y cambie el nombre de la clase de Movies a Movie. Después de realizar este cambio, haga clic en el botón Guardar (el icono de disquete) para generar la clase Movie.
Creación del controlador ASP.NET MVC
El siguiente paso consiste en crear el controlador de ASP.NET MVC. Un controlador es responsable de controlar cómo interactúa un usuario con una aplicación ASP.NET MVC.
Siga estos pasos:
- En la ventana del Explorador de soluciones, haga clic con el botón derecho en la carpeta Controllers y seleccione la opción de menú Agregar, Controlador.
- En el cuadro de diálogo Agregar controlador, escriba el nombre HomeController y active la casilla Agregar métodos de acción para escenarios de creación, actualización y detalles (vea la figura 8).
- Haga clic en el botón Agregar para agregar el nuevo controlador al proyecto.
Después de completar estos pasos, se crea el controlador de la lista 1. Observe que contiene los métodos Index, Details, Create y Edit. En las secciones siguientes, agregaremos el código necesario para que funcionen estos métodos.
Figura 08: Adición de un nuevo controlador de ASP.NET MVC (haga clic para ver la imagen a tamaño completo)
Lista 1: Controllers\HomeController.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Ajax;
namespace MovieApp.Controllers
{
public class HomeController : Controller
{
//
// GET: /Home/
public ActionResult Index()
{
return View();
}
//
// GET: /Home/Details/5
public ActionResult Details(int id)
{
return View();
}
//
// GET: /Home/Create
public ActionResult Create()
{
return View();
}
//
// POST: /Home/Create
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Create(FormCollection collection)
{
try
{
// TODO: Add insert logic here
return RedirectToAction("Index");
}
catch
{
return View();
}
}
//
// GET: /Home/Edit/5
public ActionResult Edit(int id)
{
return View();
}
//
// POST: /Home/Edit/5
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(int id, FormCollection collection)
{
try
{
// TODO: Add update logic here
return RedirectToAction("Index");
}
catch
{
return View();
}
}
}
}
Lista de registros de base de datos
El método Index() del controlador Home es el método predeterminado para una aplicación ASP.NET MVC. Al ejecutar una aplicación ASP.NET MVC, el método Index() es el primer método de controlador al que se llama.
Usaremos el método Index() para mostrar la lista de registros de la tabla de base de datos Movies. Usaremos las clases de modelo de base de datos que creamos anteriormente para recuperar los registros de la base de datos de películas con el método Index().
He modificado la clase HomeController en la lista 2 para que incluya un nuevo campo privado denominado _db. La clase MoviesDBEntities representa nuestro modelo de base de datos y usaremos esta clase para comunicarnos con nuestra base de datos.
También he modificado el método Index() en la lista 2. El método Index() usa la clase MoviesDBEntities para recuperar todos los registros de películas de la tabla de base de datos Movies. La expresión _db. MovieSet.ToList() devuelve una lista de todos los registros de películas de la tabla de base de datos Movies.
La lista de películas se pasa a la vista. Todo lo que se pasa al método View() se pasa a la vista como datos de vista.
Lista 2: Controllers/HomeController.cs (método Index modificado)
using System.Linq;
using System.Web.Mvc;
using MovieApp.Models;
namespace MovieApp.Controllers
{
public class HomeController : Controller
{
private MoviesDBEntities _db = new MoviesDBEntities();
public ActionResult Index()
{
return View(_db.MovieSet.ToList());
}
}
}
El método Index() devuelve una vista denominada Index. Es necesario crear esta vista para mostrar la lista de registros de base de datos de películas. Siga estos pasos:
Debe compilar el proyecto (seleccione la opción de menú Compilar, Compilar solución) antes de abrir el cuadro de diálogo Agregar vista o no aparecerá ninguna clase en la lista desplegable Ver clase de datos.
- Haga clic con el botón derecho en el método Index() en el editor de código y seleccione la opción de menú Agregar vista (vea la figura 9).
- En el cuadro de diálogo Agregar vista, compruebe que está activada la casilla Crear una vista fuertemente tipada.
- En la lista desplegable Ver contenido, seleccione el valor Lista.
- En la lista desplegable Clase de datos de vista, seleccione el valor MovieApp.Models.Movie.
- Haga clic en el botón Agregar para crear la nueva vista (vea la figura 10).
Después de completar estos pasos, se agrega una nueva vista denominada Index.aspx a la carpeta Views\Home. El contenido de la vista Index se incluye en la lista 3.
Figura 09: Adición de una vista desde una acción de controlador (haga clic para ver la imagen a tamaño completo)
Figura 10: Creación de una nueva vista con el cuadro de diálogo Agregar vista (haga clic para ver la imagen a tamaño completo)
Lista 3: Views\Home\Index.aspx
<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/Site.Master" Inherits="System.Web.Mvc.ViewPage<IEnumerable<MovieApp.Models.Movie>>" %>
<asp:Content ID="Content1" ContentPlaceHolderID="TitleContent" runat="server">
Index
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
<h2>Index</h2>
<table>
<tr>
<th></th>
<th>
Id
</th>
<th>
Title
</th>
<th>
Director
</th>
<th>
DateReleased
</th>
</tr>
<% foreach (var item in Model) { %>
<tr>
<td>
<%= Html.ActionLink("Edit", "Edit", new { id=item.Id }) %> |
<%= Html.ActionLink("Details", "Details", new { id=item.Id })%>
</td>
<td>
<%= Html.Encode(item.Id) %>
</td>
<td>
<%= Html.Encode(item.Title) %>
</td>
<td>
<%= Html.Encode(item.Director) %>
</td>
<td>
<%= Html.Encode(String.Format("{0:g}", item.DateReleased)) %>
</td>
</tr>
<% } %>
</table>
<p>
<%= Html.ActionLink("Create New", "Create") %>
</p>
</asp:Content>
La vista Index muestra todos los registros de películas de la tabla de base de datos Movies dentro de una tabla HTML. La vista contiene un bucle foreach que recorre en iteración cada película representada por la propiedad ViewData.Model. Si ejecuta la aplicación presionando la tecla F5, verá la página web de la figura 11.
Figura 11: Vista Index (haga clic para ver la imagen de tamaño completo)
Creación de nuevos registros de base de datos
La vista Index que creamos en la sección anterior incluye un vínculo para crear nuevos registros de base de datos. Vamos a continuar e implementar la lógica y crear la vista necesaria para crear nuevos registros de base de datos de películas.
El controlador Home contiene dos métodos Create(). El primer método Create() no tiene parámetros. Esta sobrecarga del método Create() se usa para mostrar el formulario HTML para crear nuevos registros de base de datos de películas.
El segundo método Create() tiene un parámetro FormCollection. Se llama a esta sobrecarga del método Create() cuando el formulario HTML para crear nuevas películas se publica en el servidor. Observe que este segundo método Create() tiene un atributo AcceptVerbs que impide que se llame al método a menos que se realice una operación HTTP POST.
Este segundo método Create() se ha modificado en la clase HomeController actualizada de la lista 4. La nueva versión del método Create() acepta un parámetro Movie y contiene la lógica para insertar una nueva película en la tabla de base de datos Movies.
Nota:
Observe el atributo Bind. Dado que no queremos actualizar la propiedad Movie Id del formulario HTML, es necesario excluir explícitamente esta propiedad.
Lista 4: Controllers\HomeController.cs (método Create modificado)
//
// GET: /Home/Create
public ActionResult Create()
{
return View();
}
//
// POST: /Home/Create
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Create([Bind(Exclude="Id")] Movie movieToCreate)
{
if (!ModelState.IsValid)
return View();
_db.AddToMovieSet(movieToCreate);
_db.SaveChanges();
return RedirectToAction("Index");
}
Visual Studio facilita la creación del formulario para crear un nuevo registro de base de datos de películas (vea la figura 12). Siga estos pasos:
- Haga clic con el botón derecho en el método Create() en el editor de código y seleccione la opción de menú Agregar vista.
- Compruebe que la casilla Crear una vista fuertemente tipada esté activada.
- En la lista desplegable Ver contenido, seleccione el valor Crear.
- En la lista desplegable Clase de datos de vista, seleccione el valor MovieApp.Models.Movie.
- Haga clic en el botón Agregar para crear la nueva vista.
Figura 12: Añadir la vista Create (haga clic para ver la imagen de tamaño completo)
Visual Studio genera automáticamente la vista de la lista 5. Esta vista contiene un formulario HTML que incluye campos que corresponden a cada una de las propiedades de la clase Movie.
Lista 5: Views\Home\Create.aspx
<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/Site.Master" Inherits="System.Web.Mvc.ViewPage<MovieApp.Models.Movie>" %>
<asp:Content ID="Content1" ContentPlaceHolderID="TitleContent" runat="server">
Create
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
<h2>Create</h2>
<%= Html.ValidationSummary("Create was unsuccessful. Please correct the errors and try again.") %>
<% using (Html.BeginForm()) {%>
<fieldset>
<legend>Fields</legend>
<p>
<label for="Id">Id:</label>
<%= Html.TextBox("Id") %>
<%= Html.ValidationMessage("Id", "*") %>
</p>
<p>
<label for="Title">Title:</label>
<%= Html.TextBox("Title") %>
<%= Html.ValidationMessage("Title", "*") %>
</p>
<p>
<label for="Director">Director:</label>
<%= Html.TextBox("Director") %>
<%= Html.ValidationMessage("Director", "*") %>
</p>
<p>
<label for="DateReleased">DateReleased:</label>
<%= Html.TextBox("DateReleased") %>
<%= Html.ValidationMessage("DateReleased", "*") %>
</p>
<p>
<input type="submit" value="Create" />
</p>
</fieldset>
<% } %>
<div>
<%=Html.ActionLink("Back to List", "Index") %>
</div>
</asp:Content>
Nota:
El formulario HTML generado por el cuadro de diálogo Agregar vista genera un campo de formulario Id. Dado que la columna Id es una columna Identity, no necesitamos este campo de formulario y se puede quitar de forma segura.
Después de agregar la vista Create, podrá agregar nuevos registros de películas a la base de datos. Ejecute la aplicación presionando la tecla F5 y haga clic en el vínculo Crear nuevo para ver el formulario de la figura 13. Si completa y envía el formulario, se crea un nuevo registro de la base de datos de películas.
Observe que obtiene automáticamente la validación de formularios. Si no escribe una fecha de lanzamiento para una película, o si escribe una fecha de lanzamiento no válida, el formulario se vuelve a mostrar y el campo de fecha de lanzamiento se resalta.
Figura 13: Creación de un nuevo registro de base de datos de películas (haga clic para ver la imagen a tamaño completo)
Edición de registros de base de datos existentes
En las secciones anteriores, analizamos cómo se pueden enumerar y crear nuevos registros de base de datos. En esta sección final, se describe cómo editar los registros de base de datos existentes.
En primer lugar, es necesario generar el formulario Edit. Este paso es sencillo, ya que Visual Studio genera automáticamente el formulario Edit. Abra la clase HomeController.cs en el editor de código de Visual Studio y siga estos pasos:
- Haga clic con el botón derecho en el método Edit() en el editor de código y seleccione la opción de menú Agregar vista (vea la figura 14).
- Active la casilla Crear una vista fuertemente tipada.
- En la lista desplegable Ver contenido, seleccione el valor Editar.
- En la lista desplegable Clase de datos de vista, seleccione el valor MovieApp.Models.Movie.
- Haga clic en el botón Agregar para crear la nueva vista.
Al realizar estos pasos, se agrega una nueva vista denominada Edit.aspx a la carpeta Views\Home. Esta vista contiene un formulario HTML para editar un registro de película.
Figura 14: Adición de la vista Edit (haga clic para ver la imagen a tamaño completo)
Nota:
La vista Edit contiene un campo de formulario HTML que corresponde a la propiedad Movie Id. Dado que no desea que los usuarios editan el valor de la propiedad Id, debe quitar este campo de formulario.
Por último, es necesario modificar el controlador Home para que admita la edición de un registro de base de datos. La clase HomeController actualizada se encuentra en la lista 6.
Lista 6: Controllers\HomeController.cs (métodos Edit)
//
// GET: /Home/Edit/5
public ActionResult Edit(int id)
{
var movieToEdit = (from m in _db.MovieSet
where m.Id == id
select m).First();
return View(movieToEdit);
}
//
// POST: /Home/Edit/5
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(Movie movieToEdit)
{
var originalMovie = (from m in _db.MovieSet
where m.Id == movieToEdit.Id
select m).First();
if (!ModelState.IsValid)
return View(originalMovie);
_db.ApplyPropertyChanges(originalMovie.EntityKey.EntitySetName, movieToEdit);
_db.SaveChanges();
return RedirectToAction("Index");
}
En la lista 6, he agregado lógica adicional a ambas sobrecargas del método Edit(). El primer método Edit() devuelve el registro de la base de datos de películas que corresponde al parámetro Id pasado al método. La segunda sobrecarga realiza las actualizaciones de un registro de película en la base de datos.
Tenga en cuenta que debe recuperar la película original y, luego, llamar a ApplyPropertyChanges() para actualizar la película existente en la base de datos.
Resumen
El propósito de este tutorial era darle una idea de la experiencia de creación de una aplicación ASP.NET MVC. Espero que haya descubierto que es muy similar a la experiencia de crear una aplicación Active Server Pages o ASP.NET.
En este tutorial, hemos examinado solo las características más básicas del marco ASP.NET MVC. En futuros tutoriales, profundizaremos en temas como controladores, acciones de controlador, vistas, datos de vistas y asistentes HTML.
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de