Pop

Curso .NET Core en C# - 34.Creamos nuestro propio log

34.Creamos nuestro propio log

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  •  En este vídeo discutiremos cómo registrar nuestros propios mensajes, advertencias y excepciones usando la interfaz ILogger de ASP.NET Core. Si hay excepciones, mientras los usuarios usan nuestra aplicación, necesitamos registrar las excepciones en algún lugar. Un desarrollador puede revisar el registro de  excepciones y proporcionar una solución si es necesario. 

  • Os dejo parte del código visto en el vídeo
    • En el controlador agregamos:
private readonly ILogger<ErrorController> logs;
public ErrorController(ILogger<ErrorController> log)
{
this.logs = log;
}
    •   Agregamos ademas:
   
        logs.LogError($"Ruta del ERROR: {exceptionHandlerPathFeature.Path} " +
                   $"Excepcion: {exceptionHandlerPathFeature.Error}" +
                   $"Traza del ERROR: {exceptionHandlerPathFeature.Error.StackTrace}");


    • Instalamos paquete de NUGET y creamos archivo de configuración. nlog.config:

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<targets>
   <target name="allfile" xsi:type="File"
            fileName="D:\Videos\Ejemplos codigo\NetCore\nlog-all-${shortdate}.log"/>
  </targets>
  <rules>
    <logger name="*" minlevel="Trace" writeTo="allfile" />
  </rules>
</nlog>

    • En la clase Program.cs añadimos esto:

using NLog.Extensions.Logging;

    logging.AddNLog();

Curso .NET Core en C# - 33.Controlando excepciones globales

33.Controlando excepciones globales

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  • En este vídeo veremos cómo controlar las excepciones globales en ASP.NET Core MVC.Para ello forzamos una excepción:   throw new Exception("Forzando error..........");  y hacemos los siguientes pasos:
            1) Configuramos en el archivo  launchsettings.
    2) Cuando el entorno no sea desarrollo agregamos en el método configure de la clase startup:
app.UseExceptionHandler("/Error");
           3)Implementamos el ErrorController que recupera los detalles de la excepción y devuelve la vista de error personalizada. 
4)Creamos vista error genérico.

  • En el vídeo lo podéis ver con más detalles:


Curso .NET Core en C# - 32.Aprende a controlar los errores

32.Aprende a controlar los errores 

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  • En este vídeo empezaremos a ver como controlar los errores 404 en las peticiones. 
  • Os dejo parte del código visto en el vídeo:
    • Código añadido en el controlador en la vista detalles:

            if (detalles.amigo == null)
            {
                Response.StatusCode = 404;
                return View("AmigoNoEncontrado", id);
            }
    • Nos creamos la vista AmigoNoEncontrado:
@model int

@{
    ViewBag.Title = "404 Error";
}

<div class="alert alert-danger mt-1 mb-1">
    <h4>404 Recurso no encontrado:</h4>
    <hr />
    <h5>
        Amigo con ID = @Model no encontrado
    </h5>
</div>

<a asp-controller="home" asp-action="index" class="btn btn-outline-success"
   style="width:auto">Ver todos los amigos</a>


  • Si queremos manejar los errores 404 de una manera centralizada podemos hacerlo desde el método configure de la clase startup. Redirigimos a app.UseStatusCodePagesWithRedirects("/Error/{0}");
     public class ErrorController : Controller
    {

        [Route("Error/{statusCode}")]
        public IActionResult HttpStatusCodeHandler(int statusCode)
        {
            switch (statusCode)
            {
                case 404:
                    ViewBag.ErrorMessage = "El recurso solicitado no existe";
                    break;
            }

            return View("Error");
        }
    }
@{
    ViewBag.Title = "Error";
}

<h1>@ViewBag.ErrorMessage</h1>

<a asp-action="index" asp-controller="home">
    Ir a la página de inicio
</a>

Curso .NET Core en C# - 31.Entity Framework: Creamos vista para editar

31.Entity Framework: Creamos vista para editar

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  • En este vídeo veremos como implementar la vista Editar para modificar los datos existentes.Queremos mostrar los datos de los amigos existentes en la vista de edición. El usuario puede cambiar los detalles y hacer clic en el botón Actualizar para actualizar los datos en nuestra base de datos.



  • Cuando se hace clic en el botón Editar, queremos redirigir a la vista Editar por lo que enlazamos de la siguiente manera:
 <a asp-controller="home" asp-action="edit" asp-route-id="@amigo.Id" class="btn btn-primary m-1">Editar</a>
  •  Nos creamos además la siguiente clase para los datos que necesitara utilizar nuestra vista EditarAmigoModelo que hereda de la CrearAmigoModelo. Utilizamos el enfoque de herencia para no duplicar el código Además de las propiedades que heredamos de la clase CrearAmigoModelo, también necesitamos Id y una propiedad con la ruta de la foto existente
   public class EditarAmigoModelo:CrearAmigoModelo
    {
        public int Id { get; set; }
        public string rutaFotoExistente { get; set; }
    }

  • Además añadimos en el controlador el siguiente código:
      public ViewResult Edit(int id)
        {
            Amigo amigo = amigoAlmacen.dameDatosAmigo(id);
            EditarAmigoModelo amigoEditar = new EditarAmigoModelo
            {
                Id = amigo.Id,
                Nombre = amigo.Nombre,
                Email = amigo.Email,
                Ciudad = amigo.Ciudad,
                rutaFotoExistente = amigo.rutaFoto
            };
            return View(amigoEditar);
        }

Y en la vista edit.cshtml

@model EditarAmigoModelo

@{
    ViewBag.Title = "Editar Amigo";
    //El operador de uso combinado de NULL ?? devuelve el valor del operando izquierdo si no es null; en caso contrario, 
    //evalúa el operando derecho y devuelve su resultado. 
    var rutafoto = "~/images/" + (Model.rutaFotoExistente ?? "ChicaCodigo.jpg");


}

<form asp-controller="home" asp-action="edit" enctype="multipart/form-data" method="post" class="mt-3">
    <div asp-validation-summary="All" class="text-danger">
    </div>
    @*Guardamos en elemtos hidden el id y la ruta de la foto exxistente*@
    <input hidden asp-for="Id" />
    <input hidden asp-for="rutaFotoExistente" />

    @*Enlazamos los datos correspondientes para mostrarlos en los controles*@
    <div class="form-group row">
        <label asp-for="Nombre" class="col-sm-2 col-form-label"></label>
        <div class="col-sm-10">
            <input asp-for="Nombre" class="form-control" placeholder="Name">
            <span asp-validation-for="Nombre" class="text-danger"></span>
        </div>
    </div>
    <div class="form-group row">
        <label asp-for="Email" class="col-sm-2 col-form-label"></label>
        <div class="col-sm-10">
            <input asp-for="Email" class="form-control" placeholder="Email">
            <span asp-validation-for="Email" class="text-danger"></span>
        </div>
    </div>

    <div class="form-group row">
        <label asp-for="Ciudad" class="col-sm-2 col-form-label"></label>
        <div class="col-sm-10">
            <select asp-for="Ciudad" class="custom-select mr-sm-2"
                    asp-items="Html.GetEnumSelectList<Provincia>()">
                <option value="">Please Select</option>
            </select>
            <span asp-validation-for="Ciudad" class="text-danger"></span>
        </div>
    </div>

    <div class="form-group row">
        <label asp-for="Foto" class="col-sm-2 col-form-label"></label>
        <div class="col-sm-10">
            <div class="custom-file">
                <input asp-for="Foto" class="custom-file-input form-control">
                <label class="custom-file-label">Click para modifcar al imagen</label>
            </div>
        </div>
    </div>

    @*Mostramos la foto del empleado*@
    <div class="form-group row col-sm-4 offset-4">
        <img class="imageThumbnail" src="@rutafoto" asp-append-version="true" />
    </div>

    <div class="form-group row">
        <div class="col-sm-10">
            <button type="submit" class="btn btn-primary">Editar</button>
            <a asp-action="index" asp-controller="home" class="btn btn-primary">Volver</a>
        </div>
    </div>

    @section Scripts {
        <script>
            $(document).ready(function () {
                $('.custom-file-input').on("change", function () {
                    var fileName = $(this).val().split("\\").pop();
                    $(this).next('.custom-file-label').html(fileName);
                });
            });
        </script>
    }
</form>


En el controlador añadimos el siguiente código:

       [HttpPost]
        public IActionResult Edit(EditarAmigoModelo model)
        {
            //Comprobamos que los datos son correctos
            if (ModelState.IsValid)
            {
                // Obtenemos los datos de nuestro amigo de la BBDD
                Amigo amigo = amigoAlmacen.dameDatosAmigo(model.Id);
                // Actualizamos los datos de nuestro objeto del modelo
                amigo.Nombre = model.Nombre;
                amigo.Email = model.Email;
                amigo.Ciudad = model.Ciudad;

                
                if (model.Foto != null)
                {
                    //Si el usuario sube una foto.Debe borrarse la anterior
                    if (model.rutaFotoExistente != null)
                    {
                        string ruta = Path.Combine(hosting.WebRootPath,"images", model.rutaFotoExistente);
                        System.IO.File.Delete(ruta);
                    }
                    //Guardamos la foto en wwwroot/images
                    amigo.rutaFoto = SubirImagen(model);
                }

                Amigo amigoModificado = amigoAlmacen.modificar(amigo);

                return RedirectToAction("index");
            }

            return View(model);
        }

        private string SubirImagen(EditarAmigoModelo model)
        {
            string nombreFichero = null;

            if (model.Foto != null)
            {
                string carpetaSubida = Path.Combine(hosting.WebRootPath, "images");
                nombreFichero = Guid.NewGuid().ToString() + "_" + model.Foto.FileName;
                string ruta = Path.Combine(carpetaSubida, nombreFichero);
                using (var fileStream = new FileStream(ruta, FileMode.Create))
                {
                    model.Foto.CopyTo(fileStream);
                }
            }

            return nombreFichero;
        }
    }

Curso .NET Core en C# - 30.Entity Framework: Guardamos imágenes

30.Entity Framework: Guardamos imágenes 

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  • En este vídeo veremos cómo cargar una imagen usando ASP.NET Core MVC con un ejemplo.El control lo añadiremos en el formualrio de creación de amigos. Lo primero que debemos hacer es preparar nuestra BBDD para almacenar este valor. Para ello preparamos nuestro modelo.Para poder almacenar la Ruta de la foto del nuevo amigo, agregamos la propiedad rutaFoto a la clase Amigo:
             public string rutaFoto { get; set; }

  • Para poder actualizar nuestra BBDD vía E.Framework agregamos una nueva migración:
    • Add-Migration AddRutaFotoAmigo
    • Actualizamos la BBDD: Update-Database
  • Para poder guardar la imagen creamos una nueva clase para ello:
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;

namespace Ejemplo1.Models
{
    public class CrearAmigoModelo
    {
        [Required(ErrorMessage = "Obligatorio"), MaxLength(100, ErrorMessage = "No más de 100 carácteres")]
        public string Nombre { get; set; }

        [Required(ErrorMessage = "Obligatorio")]
        [Display(Name = "Email")]
        [RegularExpression(@"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$", ErrorMessage = "Formato incorrecto")]
        public string Email { get; set; }

        [Required(ErrorMessage = "Debe seleccionar una ciudad")]
        public Provincia? Ciudad { get; set; }

        public IFormFile Foto { get; set; }
    }
}


  • Además necesitamos modificar la vista Create.cshtml para que este vinculado a la nueva clase que acabamos de crear en nuestro modelo y añadimos el nuevo control para seleccionar la imagen:
      <div class="form-group row">
            <label asp-for="Foto" class="col-sm-2 col-form-label"></label>
            <div class="col-sm-10">
                <div class="custom-file">
                    <input asp-for="Foto" class="form-control custom-file-input">
                    <label class="custom-file-label">Selecciona un fichero</label>
                </div>
            </div>
        </div>
        @section Scripts {
            <script>
            $(document).ready(function () {
                $('.custom-file-input').on("change", function () {
                    var fileName = $(this).val().split("\\").pop();
                    $(this).next('.custom-file-label').html(fileName);
                });
            });
            </script>
        }
  • En el vídeo podemos ver esto con más detalle:


Curso .NET Core en C# - 29.Entity Framework: Creamos nuestras tablas

29.Entity Framework: Creamos nuestras tablas

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  •  En este vídeo crearemos nuestra estructura de base de datos con entity framework core. Para ello es necesario trabajar con migraciones.Usaremos el  Package Manager Console (PMC) o la interfaz de línea de comandos (CLI). Si estás utilizando Visual Studio como yo, usa la consola del Administrador de paquetes y haz lo siguiente:
    •  Iniciar Package Manager Console en Visual Studio, haga clic en Ver - Otras ventanas - Package Manager Console
      • 1) Utiliza el comando  Add-Migration InitialCreate  para agregar una nueva migración
      • 2)Crea los métodos para trabajar con la base de datos.Yo ya los tengo preparados. Ahora codificamos sobreescribiendo el método OnModel
      • 3) Utiliza el comnado  Add-Migration SeedAmigoTable que creara dentro de la carpeta migration  un nuevo archivo además de los anteriores
      • 4)Update-Database -->Actualiza la base de datos a una migración especificada
  • En el siguiente vídeo lo puedes ver con más detalles:


  • Código de la clase AppDbContext:

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Ejemplo1.Models
{
    public class AppDbContext:DbContext
    {
        public AppDbContext(DbContextOptions<AppDbContext> options): base(options)
        {
        }

        public DbSet<Amigo> Amigos { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Amigo>().HasData(new Amigo
            {
                Id = 1,
                Nombre = "Pepe",
                Ciudad = Provincia.Madrid,
                Email = "mail@mimail.es"
            },
            new Amigo
            {
                Id = 2,
                Nombre = "juan",
                Ciudad = Provincia.Lugo,
                Email = "mail@mimail2.es"
            },
            new Amigo
            {
                Id = 3,
                Nombre = "Laura",
                Ciudad = Provincia.Cantabria,
                Email = "mail@mimail3.es"
            }

            );
        }
    }
}

Tensorflow.Tutorial Pix2Pix. 6.Más dataset para pix2pix

6.Más dataset para pix2pix

  • En esta ocasión os traigo más dataset de imágenes para que entrenéis vuestros propios modelos con otros conjuntos de imágenes. En este enlace podéis descargar algunos de los conjuntos de imágenes diponibles : https://www.kaggle.com/vikramtiwari/pix2pix-dataset
  • Os dejo un vídeo donde os cuento todo esto más detallado:

Curso .NET Core en C# - 28.Entity Framework: vemos la clase DbContext

28.Entity Framework: vemos la clase DbContext

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  •  En este vídeo veremos  una de las clases más importantes en Entity Framework Core .Lla clase DbContext. Esta es la clase que usaremos en el código de nuestra  aplicación para interactuar con la base de datos subyacente. Es esta clase la que administra la conexión de la base de datos y se usa para recuperar y guardar datos en la base de datos. Para que la clase DbContext pueda realizar cualquier trabajo útil, necesita una instancia de la clase DbContextOptions. La instancia de DbContextOptions lleva información de configuración, como la cadena de conexión, el proveedor de la base de datos que se usará, etc.
  • En el siguiente vídeo lo explicamos:

  • Os dejo el código de la clase SQLAmigoRepositorio que utilizaremos para conectar con nuestro sql:

 public class SQLAmigoRepositorio:IAmigoAlmacen
    {
        private readonly AppDbContext contexto;

        public SQLAmigoRepositorio(AppDbContext contexto)
        {
            this.contexto = contexto;
        }

        public Amigo nuevo(Amigo amigo)
        {
            contexto.Amigos.Add(amigo);
            contexto.SaveChanges();
            return amigo;
        }

        public Amigo borrar(int Id)
        {
            Amigo amigo = contexto.Amigos.Find(Id);
            if (amigo != null)
            {
                contexto.Amigos.Remove(amigo);
                contexto.SaveChanges();
            }
            return amigo;
        }

        public List<Amigo> DameTodosLosAMigos()
        {
            return contexto.Amigos.ToList();
        }

        public Amigo dameDatosAmigo(int Id)
        {
            return contexto.Amigos.Find(Id);
        }

        public Amigo modificar(Amigo amigo)
        {
            var employee = contexto.Amigos.Attach(amigo);
            employee.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
            contexto.SaveChanges();
            return amigo;
        }
    }

Curso .NET Core en C# - 27.Introducción a Entity Framework Core

27.Introducción a Entity Framework Core

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  •  En este vídeo veremos  una introducción a Entity Framework Core. Si tiene alguna experiencia con versiones anteriores de Entity Framework, encontrará muchas características familiares.¿Qué es EF Core? EF Core es un ORM (Mapeo objeto relacional).Es un software liviano, extensible y de código abierto. Al igual que .NET Core, EF Core también es multiplataforma. Funciona en Windows, Mac OS y Linux. 
  • ORM significa Object-Relational Mapper y permite a los desarrolladores trabajar con una base de datos utilizando objetos de la capa de negocio. En resumen, un ORM elimina la necesidad de la mayoría del código de acceso a datos que los desarrolladores generalmente necesitan escribir.Un ORM como EF Core puede hacer todo esto por nosotros y ahorra mucho tiempo. 
  • En el siguiente vídeo os explico todo esto con más detalle:

Tensorflow.Tutorial Pix2Pix. 5.Entrenamos el modelo

5.Entrenamos el modelo


  • En este capítulo entrenamos el modelo.Para entrenar el modelo comenzamos iterando sobre el conjunto de datos, después el generador obtiene la imagen de entrada y nosotros obtenemos una salida generada. El discriminador recibe la imagen de entrada y la imagen generada como la primera entrada. La segunda entrada es input_image y target_image. A continuación, calculamos el generador y la pérdida discriminadora. Luego, calculamos los gradientes de pérdida con respecto a las variables (entradas) del generador y del discriminador y las aplicamos al optimizador. En el siguiente vídeo lo explicamos:

  • Vemos el el código del vídeo:




#Con la siguiente función evaluamos el comportamineto del modelo generador que estamos #entrenando le pasamos imágenes de nuestro conjunto de prueba 
EPOCHS = 150
def generate_images(model, test_input, tar):
  # the training=True is intentional here since
  # we want the batch statistics while running the model
  # on the test dataset. If we use training=False, we will get
  # the accumulated statistics learned from the training dataset
  # (which we don't want)
  prediction = model(test_input, training=True)
  plt.figure(figsize=(15,15))

  display_list = [test_input[0], tar[0], prediction[0]]
  title = ['Input Image', 'Ground Truth', 'Predicted Image']

  for i in range(3):
    plt.subplot(1, 3, i+1)
    plt.title(title[i])
    # getting the pixel values between [0, 1] to plot it.
    plt.imshow(display_list[i] * 0.5 + 0.5)
    plt.axis('off')
  plt.show()
  
#Función que enlaza todos los modulos implementados
@tf.function
def train_step(input_image, target):
  with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
    #El generador toma la imagen de entrada de la función.Esta imagen es comprimida por
    #el encoder y descomprimida por el decoder y obtenemos imagen de salida
    gen_output = generator(input_image, training=True)

    #El discriminador observa lo que ha generado el generador y obtenemos
    #la salida del discriminador
    disc_real_output = discriminator([input_image, target], training=True)
    disc_generated_output = discriminator([input_image, gen_output], training=True)

    #Llamamos a las funciones generator_loss y discriminator_loss, que evaluan 
    #el comportamiento del generador y del discriminador
    gen_loss = generator_loss(disc_generated_output, gen_output, target)
    disc_loss = discriminator_loss(disc_real_output, disc_generated_output)

  #Variable para guardar los gradientes del generador
  generator_gradients = gen_tape.gradient(gen_loss,
                                          generator.trainable_variables)
     #Variable para guardar los gradientes del discrimindaor
  discriminator_gradients = disc_tape.gradient(disc_loss,
                                               discriminator.trainable_variables)
   #Optimizamos
  generator_optimizer.apply_gradients(zip(generator_gradients,
                                          generator.trainable_variables))
  discriminator_optimizer.apply_gradients(zip(discriminator_gradients,
                                              discriminator.trainable_variables))
  
#Definimos la rutina de entrenamiento en la siguiente función.
#A la función le pasamos los dataset de entrenamiento  y de test y el número de épocas.
def fit(train_ds, epochs, test_ds):
  for epoch in range(epochs):
    start = time.time()

    # Bucle para el entrenamiento
    for input_image, target in train_ds:
      train_step(input_image, target)

    clear_output(wait=True)
    for example_input, example_target in test_ds.take(1):
      generate_images(generator, example_input, example_target)

    # Cada 20 epocas salvamos el modelo
    if (epoch + 1) % 20 == 0:
      checkpoint.save(file_prefix = checkpoint_prefix)

    print ('Time taken for epoch {} is {} sec\n'.format(epoch + 1,
                                                        time.time()-start))
#Entrenamos al modelo.En mi caso algo más de un día
fit(train_dataset, EPOCHS, test_dataset)

checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
# Run the trained model on the entire test dataset
for inp, tar in test_dataset.take(30):
  generate_images(generator, inp, tar)
  

Curso .NET Core en C# - 26.Damos vida a la vista para crear amigos.

26.Damos vida a la vista para crear amigos.

  • Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos. 
  •  En este vídeo veremos como implementar todo lo necesario para dar vida a nuestra vista para crear nuevos amigos. Ya hemos visto en anteriores vídeos que cuando llega una solicitud HTTP a nuestra aplicación MVC, es el método de acción del Controlador el que maneja la solicitud entrante. Por ejemplo si queremos ver los detalles de un amigo hacemos una solicitud GET a la  siguiente URL:  http://localhost:51775/Home/Details/2

  • En el vídeo vemos como hacemos los siguientes pasos:
      1)Para poder añadir nuevos amigo los primero que hemos hecho es añadir a nuestra interface el método -->   Amigo nuevo(Amigo amigo);
        2)En nuestro objeto mock añadimos el método:
                public Amigo nuevo(Amigo amigo){
                     amigosLista.Add(amigo)
                     return amigo;
                  }
            3)En el controlador añadimos el siguiente método:
                    public RedirectToActionResult Create(Amigo a){
                            Amigo amigo = amigoAlmacen.nuevo(a);
                           return RedirectToAction("details", new { id = amigo.Id });
                          }

                  4) Como tenemos nuestra vista vinculada al objeto amigo es tan simple como en el objeto amigo hacer las siguientes modificaciones:
                          [Required]public string Nombre { get; set; }
                          [Required]public string Email { get; set; }
                    y en el controlador modificamos el método para que si la los campos no están devuelve la vista:
                       [HttpPost]
                       public IActionResult Create(Amigo a)
                             {
                                if (ModelState.IsValid){
                                        Amigo amigo = amigoAlmacen.nuevo(a);
                                         return RedirectToAction("details", new { id = amigo.Id });
                                      }
                                     return View();
                                    }
                            por último modificamos la vista.


                            Curso .NET Core en C# - 34.Creamos nuestro propio log

                            34.Creamos nuestro propio log Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de  ASP.NET...