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();
en No hay comentarios:

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:


en No hay comentarios:

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>

en No hay comentarios:

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;
        }
    }
en No hay comentarios:

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:


en 1 comentario:

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"
            }

            );
        }
    }
}
en No hay comentarios:

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:

en No hay comentarios:

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;
        }
    }

en No hay comentarios:
Suscribirse a: Entradas (Atom)

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...