Archivo de la categoría: Diseño y Programación Web

Temas relacionados con el diseño y la programación Web en todos los lenguajes: html, php, asp.net, javascript, jquery…

ASP.Net Core no refresca los cambios en las vistas

Si vienes de trabajar con ASP.Net MVC en cualquiera de sus otras versiones (incluso .Net Core 1.x), seguro que realizabas cambios en las vistas y al refrescar el navegador veías los cambios.

Esto que parecía tan fácil hasta ahora cambia con asp.net core, te lo ponen difícil, ya que comprobarás como al crear un nuevo proyecto desde 0 y empieces a trabajar los cambios no tienen efecto al realizar el refresco.

Para solucionar esto hay que hacer lo siguiente:

  1. Añadir el paquete «Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation» desde Nuget
  2. Ir al fichero Startup.cs y en el método de configuración de servicios (ConfigureServices) añadir la siguiente línea
services.AddControllersWithViews().AddRazorRuntimeCompilation();

Ayudando a la Pequeña y Mediana Empresa

Es posible que en el trabajo diario de tu empresa hayas echado en falta alguna herramienta y/o aplicación informática que mejoraría la productividad, que te ayudaría en la toma de decisiones, que facilitaría tu trabajo o cualquier otra ventaja.

También es posible que incluso hayas consultado presupuestos con alguna compañía o persona de desarrollo de software y que por sus elevados costes no se haya podido iniciar.

Y en el peor de los casos es muy probable que te hayas embaucado en un proyecto de este tipo y que te hayan dejado a medias algún trabajo, incluso después de constantes aumentos de costes y una sucesión interminable de errores en la aplicación desarrollada.

Si tu situación es cualquiera de las expuestas y sigues pensando que una aplicación a medida de tu negocio ofrecería a tu empresa muchas ventajas, te recomiendo que sigas leyendo para conocer lo que considero necesario antes de que puedas meterte en un lío innecesario.

Cosas que debes tener en cuenta antes de iniciar un proyecto de software a medida dentro de tu empresa

Antes de iniciar un proyecto con un desarrollo a medida para tu proyecto deberías de tener en cuenta algunos hechos fundamentales y que no siempre se tienen en cuenta:

Lo excesivamente barato suele salir caro

Como pasa en todos los sectores existen personas y empresas de todo tipo. En este sector también: existen personas muy profesionales tanto en empresas como autónomos o FreeLancer, pero por desgracia también existen otras personas que venden duros a cuatro pesetas y ese precisamente es el inicio de todos los problemas. Mi consejo es el siguiente: Desconfía de aquellos que te van a realizar un proyecto a medida a precio de ganga ya que seguramente el proyecto acabará sin terminar y habrás realizado una inversión inútil.

No siempre la mejor solución es una empresa

En una empresa tú no hablas directamente con la persona o personas que están haciendo realmente tu aplicación. Tu idea o concepto se puede perder o diluir a través de las numerosas personas intermediarias hasta que llegan al que realmente tiene que hacer el trabajo: que no es otro que el programador. La metodología puesta de moda años atrás en la que un analista (una persona que no tiene porque saber programar y de hecho en muchas empresas así es) obtiene los requisitos y crea un documento que luego tendrán que entender los programadores está totalmente desfasado en mi opinión y creo que es un modelo que implica muchos costes intermedios.

En una empresa no sabes la persona que realmente te hará el trabajo… todos hemos sido becarios alguna vez y nos han asignado nuestro primer proyecto ¿De verdad quieres que te toque a ti ese becario?

La creación de aplicaciones a medida son costosas en tiempo

No esperes tener un proyecto desarrollado en una semana salvo que sea algo muy sencillo. La mayor parte de las veces el desarrollo puede superar los meses de trabajo.

Las especificaciones de un proyecto siempre cambian

Un proyecto siempre es dinámico, es muy difícil encontrar un proyecto en el que los requisitos o especificaciones no se modifiquen. Por eso tanto el cliente como el desarrollador de software deben estar abiertos a posibles cambios.

 

 

7 razones para contratar un freelance

Últimamente está aumentando la contratación de freelance, autónomos, trabajadores por cuenta propia,etc. por parte de numerosas empresas. Contratar un freelance …. ¿Cuál es la razón de esta tendencia?.

Existen multitud de beneficios que puede aportar un profesional de este tipo:

Experiencia

El perfil habitual de freelance es el de una persona experimentada que ha trabajado en varias industrias, agencias, sectores y/o empresas. De este modo puede ofrecer múltiples puntos de vista sobre un mismo problema, ideas nuevas o aportar conocimientos de su sector.

Comunicación

Con un profesional freelance la comunicación es directa. ¿que quiere esto decir?… pues muy sencillo: no necesita de intermediarios como gerentes o gestores que pueden estropear la comunicación. Por lo general es el propio trabajador freelance quien hace todas las tareas. Además un profesional freelance es, entre otras cosas, un comercial que puede asesorar de primera mano a sus clientes sobre como abordar los trabajos.

Económico

Costes menores: un trabajador freelance suele trabajar  desde casa. Todo esto repercute en los costes ya que un autónomo de este tipo no tiene gastos de local. Además si un empresario contrata a un  empleado tiene que hacer frente a una nómina con sus consiguientes gatos fiscales incluso cuando el trabajador no tenga carga de trabajo o esté  en períodos de formación. Todo esto se puede ahorrar contratando un freelance.

Flexibilidad

Recurrir a un freelance puntualmente para cubrir  ciertas necesidades de negocio que, aún siendo importantes, no son el  principal objetivo de negocio permite externalizar servicios. Esto permite una alta flexibilidad. Por ejemplo: sería absurdo contratar como empleado a un fontanero en  nómina cuando quieres realizar una reforma puntual en tu local o reparar cierta avería.

Rapidez

El freelance tiene rapidez de respuesta, no tener que rendir cuentas a nadie salvo a su cliente simplifica mucho las cosas. Él es su propio jefe de proyecto. El cliente de un autónomo solamente dispondrá de un teléfono para hablar sobre su proyecto.

Motivación

El trabajador freelance está en general altamente motivado. Dedica casi el 100% de su tiempo a realizar un proyecto, son responsables con su trabajo y tiene un gran compromiso con el cliente.

Implicación

Si una empresa apuesta por un profesional de este tipo durante largo tiempo éste podrá adquirir el conocimiento de negocio necesario para ofrecer trabajos de mayor calidad y en menor cantidad de tiempo.

Problema con scroll en ventana modal bootstrap

En bootstrap al abrir una ventana modal automáticamente se desactiva el scroll de la parte que se encuentra en el background.

Si al cerrar la ventana modal no consigue restablecerse el scroll se puede utilizar el siguiente cambio en el css:

Esto es el css que hace desaparecer el scroll

.modal-open {
    overflow: hidden;
}

Se puede modificar por lo siguiente

.modal-open {
    overflow: scroll;
}

De esta manera el scroll siempre estará activo.

 

Utilizar AsyncPostBackTrigger o Update

Cuando utilizamos un UpdatePanel en Asp.Net WebForms a veces no tenemos en cuenta el uso final al que va destinado. Es decir, en ocasiones se hacen llamadas al servidor que no requieren un refresco del UpdatePanel con lo que no tiene sentido actualizarlo.

Entendiendo el UpdatePanel

Existe una propiedad fundamental para configurar el UdpatePanel y este es el UpdateMode. Puede tener 2 valores: Allways y Conditional.

Si establecemos este valor en Allways, todas las llamadas al servidor de los controles que produzcan un postback harán refrescar el panel. Esta es una opción muy rápida, que además viene por defecto, pero en mi opinión no nos ayuda nada a la hora de aprovechar al máximo los beneficios de AJAX y el UpdatePanel.

Estableciendo el valor UpdateMode en Conditional, deberemos preocuparnos nosotros de indicar qué controles realizarán el update en el panel o bien indicarle en nuestro código cuándo debe actualizarse.

Establecer los controles en la sección Triggers para indicar cuales de ellos producirán un update del panel puede parecer una buena opción, desde luego no está mal, pero ¿por qué deberíamos hacerlo si podemos indicarlo en el código mediante el método Update() del UpdatePanel?

La ventaja de utilizar el método Update() frente por ejemplo AsyncPostBackTriggers es que tenemos controlado en todo momento cuando se debe actualizar el UpdatePanel. Si, por ejemplo, tenemos un método en el servidor que responde a un click de un botón y dentro de este método tenemos condicionales que harán que el resultado sea o no visible para el usuario podremos indicar nosotros mismos cuando una acción alterará los datos visibles en pantalla mediante el método Update().

 

Realizar tareas programadas en una aplicación ASP.Net

Desarrollo y programación .net

Por circunstancias de la vida me he encontrado últimamente con varios proyectos realizados en ASP.Net que requieren realizar tareas programadas que se ejecuten en un momento concreto del día independientemente si existe o no usuarios conectados.

Como suele ocurrir existen muchas maneras de abordar esta funcionalidad:

  • Mediante Servicios Windows, siempre que tengamos total control de nuestro servidor y el entorno para realizar la tarea en cuestión (Base de Datos, acceso al sistema de ficheros, etc.)
  • Mediante WCF. También sería necesario acceso total a IIS y a su configuración.
  • Mediante programación dentro de la misma aplicación ASP.Net.

Seguro que existe alguna otra pero mi objetivo primordial en todos estos proyectos que debía realizar era optimizar los tiempos mantenimiento, para ello creo que la última solución resultaba la mejor en este caso ya que solo tendría que dedicarme a modificar un único proyecto: la aplicación ASP.Net. De otro modo tendría que instalar el servicio windows o configurar el proyecto WCF dentro del IIS.

Así que me puse a investigar por la web cuales eran las mejores prácticas de cómo realizar una tarea programada en background dentro de ASP.Net. Encontré una solución que me parecía muy clara y que muchos reportaban como buena. Su funcionamiento requería del uso de la caché de la aplicación web y el método application_start dentro del global.asax.

Su uso consistía en añadir un objeto a la cache en el contexto de ejecución para que cuando dicha cache expirara utilizara el evento para ejecutar de nuevo la tarea. La palabra clave para este método es CacheItemRemovedCallback… pero os anticipo que yo NO LO UTILIZARÉ MÁS.

No voy a adentrar en los motivos de rehusar finalmente este método pero os puedo asegurar que da problemas, incluso cuando establecemos el tiempo de inactividad a 0 dentro del pool de aplicaciones del IIS, que en principio parecía que podía ser una de las soluciones.

Investigando un poco más pude dar con un componente muy interesante: Quartz.

Su uso es muy sencillo y parece ser que existe un componente homónimo en Java.

Quartz tiene una Interfaz denominada IJob que únicamente expone un método llamado Execute(). Si deseas hacer una tarea a nivel de aplicación únicamente debes llamar JobScheduler.Start() dentro de Application_Start() del Global.asax.

using Quartz;
using Quartz.Impl;
using System;
 
namespace ScheduledTaskExample.ScheduledTasks
{
    public class JobScheduler
    {
        public static void Start()
        {
            IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
            scheduler.Start();
 
            IJobDetail job = JobBuilder.Create<MyJob>().Build();
 
            ITrigger trigger = TriggerBuilder.Create()
                .WithDailyTimeIntervalSchedule
                  (s =>
                     s.WithIntervalInHours(24)
                    .OnEveryDay()
                    .StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(0, 0))
                  )
                .Build();
 
            scheduler.ScheduleJob(job, trigger);
        }
    }
}

10 consejos para programadores C#.Net

En esta entrada daremos 10 consejos para programadores C#.Net que puedan ser de utilidad y que en muchos casos no son muy conocidos.

Desarrollo y programación .net
Programador .Net

Consejo 1: Escribir pruebas unitarias para métodos no públicos

Seguro que si trabajas con proyectos que requieren un control de calidad has tenido que introducir algún proyecto de tests que impliquen pruebas unitarias. En ese caso seguro que has tenido problemas al intentar probar algún método que no es público. C# permite hacer visibles los ensamblados internos a otros ensamblados. Para solucionarlo añadiremos el siguiente atributo en el AseemblyInfo.cs.

//Hacer visible a un determinado ensamblado
[assembly: InternalsVisibleTo("MyTestAssembly")]
Consejo 2: Usar tuplas

En ocasiones es mejor utilizar una tupla contenedora de valores tipados que utilizar clases POCO, sobre todo cuando la estructura de datos creada solo se va a utilizar en un momento puntual.

public Tuple<int, string, string> GetEmployee()
{
	int employeeId = 1001;
	string firstName = "Rudy";
	string lastName = "Koertson";

	//Crear una tupla y devolverla
	return Tuple.Create(employeeId, firstName, lastName);
}
Consejo 3: No hay necesidad de crear colecciones temporales, mejor usar yield

Habitualmente creamos estructuras temporales de tipo enumerables para devolverlas en un método. Algo parecido a lo siguiente:

public List<int> GetValuesGreaterThan100(List<int> masterCollection)
{
	List<int> tempResult = new List<int>();

	foreach (var value in masterCollection)
	{
		if (value > 100)
			tempResult.Add(value);
	}
	return tempResult;
}

En estos casos podemos ahorrar un par de líneas de código utilizando el comando yield. A continuación mostramos el ejemplo anterior pero usando yield:

public IEnumerable<int> GetValuesGreaterThan100(List<int> masterCollection)
{
	foreach (var value in masterCollection)
	{
		if (value > 100)
			yield return value;
	}
}
Consejo 4: Comunicar que el método está obsoleto

Si tu librería está siendo usada por diferentes clientes y deseas que algún método deje de ser utilizado porque existe otro método que los sustituye o simplemente porque ya no funciona puedes indicarlo con el siguiente atributo:

[Obsolete("Este método estará obsoleto pronto. Para reemplazarlo se puede utilizar el método XYZ.")]
public void MyComponentLegacyMethod()
{
	//Aquí la implementación
}

El código anterior provocaría una advertencia o warning en el código que invocara este método. Sin embargo si deseas que ya no se pueda utilizar de ninguna de las maneras utilizarías un parámetro adicional boleano como True.

[Obsolete("Este método estará obsoleto pronto. Para reemplazarlo se puede utilizar el método XYZ.", true)]
public void MyComponentLegacyMethod()
{
	//Aquí la implementación
}
Consejo 5: Recuerda que las consultas de linq son diferidas

Cuando se realiza una consulta en linq solo se ejecuta realmente cuando se accede a los resultados. Esto se llama ejecución diferida. Para que solo se ejecute una vez la consulta debemos utilizar el método ToList.

public void MyComponentLegacyMethod(List<int> masterCollection)
{
	//Sin el método ToList esta consulta de linq sería ejecutada dos veces
	var result = masterCollection.Where(i => i > 100).ToList();

	Console.WriteLine(result.Count());
	Console.WriteLine(result.Average());
}
Consejo 6: Convertir entidades de negocio usando la palabra clave Explicit

Usar Explicit para definir la conversión de entidades. El método de conversión será invocado cuando se necesite. Un ejemplo:

class Program
{
	static void Main(string[] args)
	{
		ExternalEntity entity = new ExternalEntity()
		{
			Id = 1001,
			FirstName = "Dave",
			LastName = "Johnson"
		};
		MyEntity convertedEntity = (MyEntity)entity;
	}
}

class MyEntity
{
	public int Id { get; set; }
	public string FullName { get; set; }

	public static explicit operator MyEntity(ExternalEntity externalEntity)
	{
		return new MyEntity()
		{
			Id = externalEntity.Id,
			FullName = externalEntity.FirstName + " " + externalEntity.LastName
		};
	}
}

class ExternalEntity
{
	public int Id { get; set; }
	public string FirstName { get; set; }
	public string LastName { get; set; }
}
Consejo 7: Mantener el Stack Trace original

En .Net cuando se usa un bloque catch para capturar una excepción y se vuelve a lanzar se pierde información ya que se entiende que se ha controlado y que la excepción se genera desde el bloque que la capturó. Ejemplo:

public void RunDataOperation()
{
	try
	{
		Intialize();
		ConnectDatabase();
		Execute();
	}
	catch (Exception exception)
	{
		throw exception;
	}
}

Para mantener la traza original del error haremos esto:

public void RunDataOperation()
{
	try
	{
		Intialize();
		ConnectDatabase();
		Execute();
	}
	catch (Exception)
	{
		throw;
	}
}
Consejo 8: Atributo Flags – Agrupamiento de enum

Mediante el atributo Flags dentro de una enumeración permitirá agrupar los valores de enum. A continuación un ejemplo en el que la salida será: «BlackMamba, CottonMouth, Wiper«.

class Program
{
	static void Main(string[] args)
	{
		int snakes = 14;
		Console.WriteLine((Reptile)snakes);
	}
}

[Flags]
enum Reptile
{
	BlackMamba = 2,
	CottonMouth = 4,
	Wiper = 8,
	Crocodile = 16,
	Aligator = 32
}
Consejo 9: Forzar el tipo base para un tipo genérico

Partamos de que hemos creado una clase genérica donde hay que cumplir que el tipo genérico previsto en la clase debe heredar de una interfaz específica, esto se puede hacer como se muestra en el ejemplo siguiente:

class MyGenricClass<T> where T : IMyInterface
{
	//Cuerpo de la clase iría aquí
}

O incluso a nivel de método:

class MyGenricClass
{
	public void MyGenericMethod<T>(T t) where T : IMyInterface
	{
		//Implementación genérica iría aquí
	}
}
Consejo 10: Exponer una propiedad como IEnumerable no significa que sea solo lectura

Imaginemos que creamos una clase con una propiedad de tipo IEnumerable, en este caso es posible modificar esta propiedad aunque sea solo de lectura. Un ejemplo:

class Program
{
	static void Main(string[] args)
	{
		MyClass myClass = new MyClass();
		((List<string>)myClass.ReadOnlyNameCollection).Add("######From Client#####");

		myClass.Print();
	}
}

class MyClass
{
	List<string> _nameCollection = new List<string>();
	public MyClass()
	{
		_nameCollection.Add("Rob");
		_nameCollection.Add("John");
		_nameCollection.Add("Jummy");
		_nameCollection.Add("Derek");
	}
	public IEnumerable<string> ReadOnlyNameCollection
	{
		get { return _nameCollection.AsEnumerable(); }
	}

	public void Print()
	{
		foreach (var item in ReadOnlyNameCollection)
		{
			Console.WriteLine(item);
		}
	}
}

En el código anterior hemos podido comprobar que la lista ha podido ser modificada cuando nuestra intención es que fuera solo de lectura. Para remediar esto podemos utilizar lo siguiente:

public IEnumerable<string> ReadOnlyNameCollection
{
	get { return _nameCollection.AsReadOnly(); }
}

Comparativa de rendimiento de plantillas WordPress

Como sabemos desde hace algún tiempo en muchos casos se ha ido dejando de lado el rendimiento de los sitios web dando prioridad a otros aspectos como eran la «espectacularidad» del sitio y la inserción numerosos scripts por parte del programador que ralentizaban de manera increíble la carga de una página.

Esta tendencia está cambiando en gran parte a las preferencias de buscadores como google en la red .net a situar mejor a aquellos sitios que tienen una carga de página más liviana, y así de paso para promocionar sus servicios como por ejemplo page speed service.

La razón de realizar esta comparativa de rendimiento de plantillas WordPress es simplemente analizar la evolución en este aspecto de estas themes con respecto al rendimiento. Sabemos que existen numerosas plantillas en el mercado pero nos centraremos únicamente en las que proporciona WordPress al inicio de la instalación:

  • Twenty Fifteen
  • Twenty Fourteen
  • Twenty Thirteen

Para realizar la métrica utilizaremos PageSpeed Insights de Google.

Nota: existen factores externos de terceros que pueden afectar a la carga de una página como puede ser el servidor que aloja el sitio o la velocidad de transferencia, en nuestro caso y para que la comparativa sea más justa se ha procurado realizar esta comparativa en las mismas condiciones para todas las plantillas.

Twenty Fifteen

Resultado Móvil: 64 / Resultado Ordenador: 74

Rendimiento de Plantilla Twenty Fifteen

Twenty Fourteen

Resultado Móvil: 67 / Resultado Ordenador: 78

 

Rendimiento de plantilla Twenty Fourteen

Twenty Thirteen

Resultado Móvil: 68 / Resultado Ordenador: 83

Rendimiento de plantilla Twenty Thirteen

 

 

Resultado

Como vemos no hay grandes diferencias entre ellos pero estamos viendo que la evolución de las plantillas tampoco muestra una mejora en el rendimiento.