martes, 12 de diciembre de 2017
Seguro que los que os movéis en el mundo del desarrollo web os habéis encontrado alguna vez ante un problema de scripts en un sitio web que sólo ocurre en el entorno de producción. Si habéis subido sólo el archivo minimizado, sin mapas ni nada parecido, intentar depurarlo es una pesadilla y seguro que os gustaría poder hacer pruebas en producción usando vuestro fuente original, sin tener que que hacer cambios que puedan afectar a otros visitantes.
O también se os habrá dado el caso de que necesitéis hacer cambios en un script y os da miedillo subirlo directamente a producción sin haberlo probado antes suficientemente en el entorno real. Esto es un tema especialmente peliagudo si estáis desarrollando una plataforma SaaS en la que cientos de clientes usen en sus páginas web una referencia a vuestro script y cualquier cambio en el mismo puede traer consecuencias graves para el servicio.
Por ejemplo, imaginad que prestamos un servicio similar a Google Analytics, y todos nuestros clientes tienen una referencia en sus páginas a nuestro archivo "analytics.js" para trackear sus visitas. ¿Cómo podríamos introducir cambios en dicho archivo de script para hacer pruebas en sitios donde nos interese, sin que afectara al resto de clientes ni a los visitantes de sus páginas?
A priori no parece haber una respuesta sencilla, pero sí que la hay. Sólo necesitamos Fiddler y tres minutos de nuestro tiempo para conseguirlo :)
O también se os habrá dado el caso de que necesitéis hacer cambios en un script y os da miedillo subirlo directamente a producción sin haberlo probado antes suficientemente en el entorno real. Esto es un tema especialmente peliagudo si estáis desarrollando una plataforma SaaS en la que cientos de clientes usen en sus páginas web una referencia a vuestro script y cualquier cambio en el mismo puede traer consecuencias graves para el servicio.
Por ejemplo, imaginad que prestamos un servicio similar a Google Analytics, y todos nuestros clientes tienen una referencia en sus páginas a nuestro archivo "analytics.js" para trackear sus visitas. ¿Cómo podríamos introducir cambios en dicho archivo de script para hacer pruebas en sitios donde nos interese, sin que afectara al resto de clientes ni a los visitantes de sus páginas?
A priori no parece haber una respuesta sencilla, pero sí que la hay. Sólo necesitamos Fiddler y tres minutos de nuestro tiempo para conseguirlo :)
lunes, 11 de diciembre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- Accelerated 3D VR, sure, but impress me with a nice ASCII progress bar or spinner
Scott Hanselman - Elasticsearch, Kibana and Docker using .NET Standard 2
Juan G. Carmona - .NET Value Type (struct) as a DDD Value Object
Vladimir Khorikov - ORMs for .NET Core
Jonathan Allen - ASP.NET HttpContext in async/await patterns using the Task Parallel Library – Part 3
Alessandro Bigi - Deep dive to async Main
Gunnar Peipman - Who Says C# Interfaces Can’t Have Implementations?
Brant Burnett - .NET String Interning to Improve String Comparison Performance (C# examples)
Ben Hall - Optimizing memory usage
Frans Bouma - C# 7.0 – Specification – Samples
Jorge Serrano
lunes, 4 de diciembre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- Writing smarter cross-platform .NET Core apps with the API Analyzer and Windows Compatibility Pack
Scott Hanselman - Where are the differences in execution speed of various method types come from (.NET)?
Jiří Činčura - In Parameters in C# 7.2 – Read-only References
Abhijit Jana - Knowing When to Reflect With Caller Info Attributes
Rion Williams - Listing Strongly Typed Enum Options in C#
Steve Smith - Dissecting the async methods in C#
Sergey Teplyakov - A short tale on two patterns that live in .NET
Eddy Vluggen - Working around the lack of dynamic DbProviderFactory loading in .NET Core
Rick Strahl - C# 8.0 Features: A Glimpse of the Future
Erik Dietrich
martes, 28 de noviembre de 2017
Ya tenemos ganador del sorteo, muchas gracias a todos por participar. ¡Enhorabuena @jordimoz!
Podríamos decir que NDepend es un clásico en el mundo de las herramientas que nos ayudan a mejorar la calidad de nuestro software. Creado por Patrick Smacchia en 2004, pasó a ser comercial en 2007, y desde entonces ha ido mejorando con el objetivo de permitirnos analizar nuestros proyectos desde una perspectiva que difícilmente podríamos conseguir con otras herramientas.
Ya le echamos un vistazo por aquí hace muchos años, y tenía interés por ver cómo había evolucionado el producto y cómo se había adaptado a los cambios en plataformas y tecnologías que se han producido desde entonces, para lo que Patrick me ha brindado amablemente una licencia del producto.
Pero no contento con eso, y sabiendo que tenemos afición a regalar productos para desarrolladores de vez en cuando, también ha cedido una licencia de desarrollador, valorada en 399 Euros para sortear entre los lectores del blog :)
Nota: es importante aclarar que lo que vais a leer a continuación no ha sido filtrado ni condicionado en ningún momento por el equipo de NDepend.
lunes, 27 de noviembre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- C# 7.0 – Specification: Out variables, Deconstruction, Tuples, Out variables Expression Bodied Members, Throw Expressions, Ref returns and Ref locals
Jorge Serrano (wow!) - C# 7.1, 7.2 and 8 - New and Upcoming Features
Damir Arh - Back to Basics – What is the difference between Ref and Out Keyword in C#?
Abhijit Jana - 5 C# Evolutions You May Not Know
Ahd Ben Kheder - .NET Framework setup verification tool, cleanup tool and detection sample code now support .NET Framework 4.7.1
Aaron Stebner - C# 7 Series, Part 6: Read-only structs
Mark Zhou - Creating strongly typed xUnit theory test data with TheoryData
Andrew Lock - Trying out new .NET Core Alpine Docker Images
Scott Hanselman - Analyzing performance of asynchronous .NET code with dotTrace
Alexey Totin - How to write Unit Tests for a .NET Core Application
Dhananjay Kumar - Swashbuckle Swagger UI– Prompt for Access Token (.net Core)
Chris D.
martes, 21 de noviembre de 2017
Hace unos días veíamos lo sencillo que resultaba personalizar las plantillas de generación de código para proyectos MVC desde Visual Studio, e incluso cómo crear plantillas específicas para proyectos.
Pero dado que siempre hablábamos de Visual Studio, es lógico preguntarse si posible conseguir exactamente lo mismo desde la línea de comandos o, llevándolo al extremo, en entornos no Windows como Linux o Mac, así que en este post veremos cómo conseguirlo.
Pero dado que siempre hablábamos de Visual Studio, es lógico preguntarse si posible conseguir exactamente lo mismo desde la línea de comandos o, llevándolo al extremo, en entornos no Windows como Linux o Mac, así que en este post veremos cómo conseguirlo.
lunes, 20 de noviembre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- Microservices and Docker containers: Architecture, Patterns and Development guidance (Updated for .NET Core 2.0)
César de la Torre - Announcing the Windows Compatibility Pack for .NET Core
Immo Landwerth - Introducing Nullable Reference Types in C#
Mads Torgersen - Welcome to C# 7.2 and Span
Mads Torgersen - .NET Framework November 2017 Security and Quality Rollup & .NET Core November 2017 Update
Rick Lander - Manage Project and Package References with .net CLI
Gary Woodfine - Announcing .NET 4.7.1 Tools for the Cloud
Jeffrey Fritz - A problem with extension methods
Patrick Smacchia - xUnit Roslyn analyzers
David Pine - Implementing a Text Templating Language and Engine for .NET
Alexandre Mutel - Creating a custom xUnit theory test DataAttribute to load data from JSON files
Andrew Lock - Did you know – You can check all the installed Common Language Runtime (CLR) Versions in your machine?
Abhijit Jana
lunes, 13 de noviembre de 2017
Ahí van los enlaces recopilados durante la semana pasada, celebrando en esta ocasión la tricentésima edición de la serie que comenzó hace ya más de siete años. Como siempre, espero que os resulten interesantes ;-)
.NET / .NET Core
- A DoS Attack against the C# Compiler
Matt Warren - Back to Basics – What is the difference between const and readonly in C#?
Abhijit Jana - How to Use Performance Counters with .NET Core: Current Solution, Alternatives, and the Future
Matt Watson - Creating parameterised tests in xUnit with [InlineData], [ClassData], and [MemberData]
Andrew Lock - Creating a Nuget Package - Step by Step
Matthew Proctor - Assert.AreEqual in MSTest – done right
Dror Helper - AutoMapper 6.2.0 Released
Jimmy Bogard
martes, 7 de noviembre de 2017
Trabajando con ASP.NET Core MVC desde Visual Studio, seguro que alguna vez habéis creado vistas, controladores u otros elementos utilizando las plantillas disponibles en el IDE, seleccionando la opción del menú Add > New Scaffolded Item, por lo que os habréis encontrado con un cuadro de diálogo como el siguiente:
Tras seleccionar el tipo de elemento a crear, aparecerá un segundo cuadro de diálogo solicitándonos información sobre el mismo. Por ejemplo, en la siguiente captura de pantalla se muestra el diálogo de creación de vistas MVC, donde debemos introducir el nombre de la vista, la plantilla a utilizar, la clase del Modelo para vistas tipadas, etc:
Después de cumplimentar estos datos, se generará automáticamente el código fuente del elemento indicado. Hasta aquí bien, pero, ¿qué ocurre si ese código generado no se ajusta exactamente a nuestras necesidades? O preguntándolo de otra forma, ¿es posible modificar las plantillas de generación de código utilizadas en estos casos para adaptarlas a nuestras preferencias?
Pues sí, y vamos a ver cómo :)
Tras seleccionar el tipo de elemento a crear, aparecerá un segundo cuadro de diálogo solicitándonos información sobre el mismo. Por ejemplo, en la siguiente captura de pantalla se muestra el diálogo de creación de vistas MVC, donde debemos introducir el nombre de la vista, la plantilla a utilizar, la clase del Modelo para vistas tipadas, etc:
Después de cumplimentar estos datos, se generará automáticamente el código fuente del elemento indicado. Hasta aquí bien, pero, ¿qué ocurre si ese código generado no se ajusta exactamente a nuestras necesidades? O preguntándolo de otra forma, ¿es posible modificar las plantillas de generación de código utilizadas en estos casos para adaptarlas a nuestras preferencias?
Pues sí, y vamos a ver cómo :)
lunes, 6 de noviembre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- Welcome to C# 7.1
Mads Torgersen - Dissecting the tuples in C# 7
Sergey Teplyakov - Get All C# Classes Implementing an Interface
Gary Woodfine - Fixing the error “Program has more than one entry point defined” for console apps containing xUnit tests
Andrew Lock - Catching up with C# 7.1 and C# 7.2
Jonathan Allen - C# Script Runner for .NET Core 2.0!
Filip Woj - Modernize existing .NET apps with Windows Containers and Azure
César de la Torre
lunes, 30 de octubre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- .NET Core 2.0 and ASP.NET 2.0 Core are Here
Rick Strahl - C# 8 – The Shape of the Things to Come
Nikola Živković - Mocking with FeatureToggle
Jason Roberts - Using operator overloads for concatenating file system paths in CSharp
Maarten Balliauw - .NET Core 2.1 Release: What To Expect in 2018
Ricardo Peres
martes, 24 de octubre de 2017
Pues os voy a contar una historia que me ocurrió más de una vez al comenzar a utilizar ASP.NET Core 2. Y como supongo que no seré el único, creo que puede ser interesante compartirla por aquí para evitar pérdidas de tiempo innecesarias al resto de la humanidad ;)
Resulta que varias veces he publicado un proyecto ASP.NET Core y, tras finalizar y probar un poco la aplicación, he visto que me había dejado por detrás alguna chorradilla en una vista que tenía que corregir rápidamente. En lugar de volver a publicar el proyecto completo, cuando me ocurre esto suelo a retocar la vista y actualizar sólo ese archivo en el servidor, por ejemplo desde el menú contextual del archivo en Visual Studio:
Pero en este caso, una vez finalizó la subida del archivo al servidor, pulsé F5 en el navegador para comprobar que ya estaba todo correcto y… ¡vaya, todo seguía igual que antes! No pasa nada, pensé que no había publicado bien, por lo que volví a repetir el proceso y pocos segundos después pude comprobar que los cambios seguían sin ser aplicados en el servidor. ¿Qué podía estar ocurriendo?
Ah, claro, ¡el caché! La vista era retornada por una acción MVC decorada con el filtro
Ya lo único que se me ocurría es que la publicación hubiera fallado por algún siniestro bug de Visual Studio que no dejara rastro en las trazas, así que decidí ignorar al intermediario. Fui directamente al servidor para editar manualmente el archivo de la vista y… maldición, ¡no la encuentro! :-/
¿Qué está ocurriendo aquí?
Resulta que varias veces he publicado un proyecto ASP.NET Core y, tras finalizar y probar un poco la aplicación, he visto que me había dejado por detrás alguna chorradilla en una vista que tenía que corregir rápidamente. En lugar de volver a publicar el proyecto completo, cuando me ocurre esto suelo a retocar la vista y actualizar sólo ese archivo en el servidor, por ejemplo desde el menú contextual del archivo en Visual Studio:
Pero en este caso, una vez finalizó la subida del archivo al servidor, pulsé F5 en el navegador para comprobar que ya estaba todo correcto y… ¡vaya, todo seguía igual que antes! No pasa nada, pensé que no había publicado bien, por lo que volví a repetir el proceso y pocos segundos después pude comprobar que los cambios seguían sin ser aplicados en el servidor. ¿Qué podía estar ocurriendo?
Ah, claro, ¡el caché! La vista era retornada por una acción MVC decorada con el filtro
ResponseCache
, por lo que podría ser normal que continuara llegando al navegador la versión anterior. Eliminé caché, incluso probé desde otro navegador y ¡todo seguía igual que antes!Ya lo único que se me ocurría es que la publicación hubiera fallado por algún siniestro bug de Visual Studio que no dejara rastro en las trazas, así que decidí ignorar al intermediario. Fui directamente al servidor para editar manualmente el archivo de la vista y… maldición, ¡no la encuentro! :-/
¿Qué está ocurriendo aquí?
lunes, 23 de octubre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- Announcing the .NET Framework 4.7.1
Preeti Krishna - DotNetAnywhere: An Alternative .NET Runtime
Matt Warren - The Ultimate .NET Experiment – open source project
Konrad Kokosa - Dissecting the pattern matching in C# 7
Sergey Teplyakov - Historia del lenguaje C#: pasado, presente y evolución
Erik Dietrich (traducido por CampusMVP) - Forgotten .NET Gem — StringDictionary
James M. Curran - .NET Standard Selector
Immo Landwerth - RyuJIT Just-in-Time Compiler Optimization Enhancements
Joseph Tremoulet - C# 7.2 New Features With Visual Studio 2017
Banketeshvar Narayan - .Net Core Dependency Injection
Jared Nance - An Elasticsearch Tutorial for .NET Developers
Ivan Cesar - Running tests with dotnet xunit using Cake
Andrew Lock - Create a .NET Core 2 application on Linux with Visual Studio Code
Benjamin Perkins - Lambdas and Local Functions
Andy Gocke - Free .NET Core eBook, including ASP.NET Core and EF Core
Andrew Lock
martes, 17 de octubre de 2017
Puedes encontrar una versión actualizada de este post, que describe una forma mejor de hacerlo:
https://www.variablenotfound.com/2018/05/implementando-mas-facilmente-background.html
https://www.variablenotfound.com/2018/05/implementando-mas-facilmente-background.html
Es relativamente frecuente encontrar aplicaciones en las que necesitamos disponer de un proceso en background ejecutándose de forma continua. Hace poco hablábamos de IApplicationLifetime, un servicio del framework que nos permitía introducir código personalizado al iniciar y detener las aplicaciones, y probablemente habréis pensado que éste sería un buen sitio para gestionar el inicio y finalización de estas tareas en segundo plano.
Y aunque es posible, ASP.NET Core proporciona otras fórmulas más apropiadas para conseguirlo: los hosted services. Mediante este mecanismo, podemos crear servicios que serán gestionados por el host, y que serán iniciados y finalizados automáticamente junto con la aplicación.
lunes, 16 de octubre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- How to create a self contained .Net core application?
Anuraj Parameswaran - Introducing Oakton — Command line parsing minus the usual cruft
Jeremy Miller - Let in LinQ
Juan Francisco Morales Larios - .NET Flux Toolkit Nuget Announcement
Alex Dunn - Speech Recognition in Mono and .NET C#
Dave Mathews - What do C# values look like in WinDbg
Benjamin Perkins - Avoiding the NullReferenceException
Derek Comartin - Hide Compiler Warnings in Your Spare Time
Tim Patrick
martes, 10 de octubre de 2017
Imaginad una aplicación ASP.NET Core MVC en la que insertamos un enlace o botón que dirige el navegador hacia la siguiente acción, que realiza una operación compleja y retorna un resultado:
seres poseídos por una entidad demoníaca impacientes, lo normal es que se lancen en un feroz ataque contra el sistema, refrescando la página o pulsando repetidamente el botón de envío como si no hubiera un mañana. Todos hemos escuchado y sufrido en nuestras carnes una agresión de este tipo: “espera, esto parece que no va: click-click-click-click-click-click-click…”
Obviamente, esto no hace sino empeorar las cosas. El servidor, que ya estaba ocupado intentando responder la primera petición, no tiene ya que atender a una, sino a todas las que se han generado tras este ataque, cuando en realidad no tiene sentido: para tranquilizar al usuario basta con entregarle el resultado de una de ellas, por lo que todos los hilos sobrantes simplemente están malgastando recursos del servidor realizando operaciones para obtener resultados que nadie va a consumir.
Estaría bien poder cancelar esas peticiones largas si tenemos la seguridad de que ningún cliente está esperándolas, ¿verdad?
public async Task<IActionResult> GetTheAnswerToLifeUniverseAndEverything()
{
await Task.Delay(30000); // Simulando un proceso costoso...
return Content("42!");
}
Cuando nuestros usuarios pulsen dicho botón, necesariamente habrán de esperar varios segundos para obtener una respuesta. Pero como suelen ser Obviamente, esto no hace sino empeorar las cosas. El servidor, que ya estaba ocupado intentando responder la primera petición, no tiene ya que atender a una, sino a todas las que se han generado tras este ataque, cuando en realidad no tiene sentido: para tranquilizar al usuario basta con entregarle el resultado de una de ellas, por lo que todos los hilos sobrantes simplemente están malgastando recursos del servidor realizando operaciones para obtener resultados que nadie va a consumir.
Estaría bien poder cancelar esas peticiones largas si tenemos la seguridad de que ningún cliente está esperándolas, ¿verdad?
lunes, 9 de octubre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- Swashbuckle con ASP.NET Core y AAD B2C
Eduard Tomás - Roslyn Primer – Part I: Anatomy of a Compiler
Anthony D. Green - Dissecting the local functions in C# 7
Sergey Teplyakov - User Interface Unit Tests with .NET Core
Ricardo Peres - C# 7 Series, Part 5: Private Protected
Mark Zhou
martes, 3 de octubre de 2017
Al dar el salto a una nueva tecnología como ASP.NET Core, en muchas ocasiones nos encontramos con el problema de no saber cómo hacer cosas que con las tecnologías tradicionales teníamos completamente controladas. Ya hemos comentado por aquí varios casos (como el Application_Start(), los custom errors o las variables de sesión) y hemos visto cómo se mapean estas funciones al nuevo framework, pero hay muchos más.
Otro ejemplo muy habitual lo encontramos con
Otro ejemplo muy habitual lo encontramos con
MapPath()
, un método perteneciente a la clase HttpServerUtility
de ASP.NET "clásico" que utilizábamos para obtener una ruta física a partir de la ruta virtual o relativa de un recurso. Por ejemplo, en el siguiente código mostramos cómo averiguar la ruta en disco de una imagen utilizando este método:var path = HttpContext.Current.Server.MapPath("~/images/image.jpg"); // path = C:\inetpub\wwwroot\mysite\images\image.jpgPues bien, ni en ASP.NET Core ni en MVC tenemos disponible la clase
System.Web.HttpContext
, ni por tanto una propiedad Server
de tipo HttpServerUtility
que usábamos para invocar al método MapPath()
. Sin embargo, disponemos de herramientas alternativas que nos permiten conseguir lo mismo, aunque, eso sí, de forma algo menos directa.
lunes, 2 de octubre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET / .NET Core
- Plataforma .NET, Plataforma .NET Core y Xamarin: el panorama de las tecnologías de desarrollo Microsoft en 2018
José Manuel Alarcón - .NET Framework 4.7.1 Runtime and Compiler Features
Preeti Krishna - Possessive apostrophes in C# identifiers
Simon Harriyott - The Book of the Runtime - The internals of the .NET Runtime that you won’t find in the documentation
Scott Hanselman - Interesting C# 7.x features - Part 02
Malisa Ncube - Better Performance from Async Operations
Steve Smith - Upcoming features and enhancements in C# 7.2
Kapil Khandelwal - C# Tools to Help with Your Code Quality
Erik Dietrich - Interface Method Implementation C# 8.0
DotNetCrunch - .NET Core CLI and MSBUILD Cheat Sheet
Carlos Mendible
martes, 26 de septiembre de 2017
En las versiones clásicas de ASP.NET, el archivo Global.asax proporcionaba vías para implementar lógica personalizada cuando la aplicación arrancaba y era detenida, lo que podía resultar bastante útil, por ejemplo, para registrar estos eventos en un log, precargar cachés, inicializar bases de datos, “engancharnos” a servicios externos, etc.
Por ejemplo, en el siguiente código vemos cómo podíamos aprovechar los eventos
Por ejemplo, en el siguiente código vemos cómo podíamos aprovechar los eventos
Application_Start()
y Application_End()
para guardar un registro básico de estos sucesos:public class MvcApplication : System.Web.HttpApplication
{
private static string _logFile;
protected void Application_Start()
{
...
_logFile = Server.MapPath("log.txt");
File.AppendAllText(_logFile, DateTime.Now + ": Starting\n");
}
protected void Application_End()
{
File.AppendAllText(_logFile, DateTime.Now + ": Stopping\n");
}
}
Sabemos que en ASP.NET Core no existe Global.asax, por lo esta fórmula ya no está disponible. Sin embargo, el nuevo framework ofrece una alternativa bastante razonable mediante el interfaz IApplicationLifetime
, proporcionando, entre otras cosas, vías para suscribirnos a eventos relacionados con el ciclo de vida de una aplicación.
lunes, 25 de septiembre de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET/.NET Core
- .NET Core vs .NET Framework: How to Pick a .NET Runtime for an Application
Angela Stringfellow - 3 New C# 8 Features We Are Excited About
Simon Timms - New Free C# 7.1: What's New Quick Start eBook
Jason Roberts - What would a cross-platform .NET UI Framework look like? Exploring Avalonia
Scott Hanselman - .NET Framework 4.7.1 Accessibility and WPF Improvements
Preeti Krishna - Interesting C# 7.x features - 01
Malisa Nnube - C# 7.1’s default value expressions enhancement: default literal expressions
Kapil Khandelwal - Conditional TargetFrameworks for Multi-Targeted .NET SDK Projects on Cross-Platform Builds
Rick Strahl - How to Create a .NET Core CLI Console App as an EXE Instead of a DLL
Jon Gallant - Adding circuit breakers to your .NET applications
Richard Seroter - Deep Dive into OWIN Katana
Kusnaditjung
martes, 19 de septiembre de 2017
Como ya sabréis, hace algunas semanas Microsoft anunció la disponibilidad de, entre otras tecnologías, ASP.NET Core 2.0, y me complace anunciaros que hace pocos días hemos lanzado desde CampusMVP el curso que muchos andabais esperando para dar el salto: Desarrollo Web con ASP.NET Core 2 MVC.
Se trata de una revisión del curso sobre ASP.NET Core MVC, que tan buena acogida y críticas ha tenido hasta el momento, actualizando conceptos y reflejando las novedades en APIs, funcionalidades y herramientas con las que esta segunda versión del framework promete revolucionar nuestra forma de desarrollar aplicaciones y servicios para la web.
En este post intentaremos responder a las siguientes preguntas:
- ¿En qué consiste el curso de ASP.NET Core 2 MVC?
- ¿Cuáles son los contenidos del curso?
- ¿Es este curso para mi?
- ¿Qué conocimientos previos necesito para seguir el curso?
- ¿Y qué ocurre con MVC 5 o los demás frameworks basados en ASP.NET 4.x?
- Me convence, ¿cuándo empezamos?
¿En qué consiste el curso de ASP.NET Core 2 MVC?
Se trata de un curso impartido totalmente online a través de la prestigiosa plataforma de CampusMVP, sin horarios y a tu propio ritmo. La duración del curso está estimada en 12 semanas con una dedicación media de 7 u 8 horas semanales, y durante las cuales, dado que soy el tutor, contarás con mi asistencia para resolver tus dudas y ayudarte a lo largo de tu proceso de aprendizaje.El temario consta de más de 150 temas que recorren exhaustivamente el framework ASP.NET Core 2.0 MVC desde su base, y que podrás descargar en formato PDF (más de 400 páginas) para utilizarlo como referencia al finalizar el curso. Además del contenido teórico, el curso está salpicado por numerosos ejercicios y prácticas propuestas que te ayudarán a asimilar mejor los conceptos principales, autoevaluaciones, recursos adicionales, aplicaciones de ejemplo, consejos y buenas prácticas, y más de tres horas de vídeo para ver en vivo el funcionamiento de algunas características.
Al finalizar el curso obtendrás un diploma que te permitirá acreditar su realización, así como incluirlo en tu perfil certificado de CampusMVP, un perfil online verificable por terceros donde puedes demostrar qué has aprendido con nosotros.
¿Cuáles son los contenidos del curso?
El curso realiza un recorrido completo por ASP.NET Core MVC partiendo desde cero. Y no podemos decir que nos andemos mucho por las ramas… Tras una breve bienvenida, empezamos presentando ASP.NET Core, describiendo su estructura, arquitectura y principios básicos de funcionamiento, y pasaremos rápidamente a la acción.Veremos cómo se crean y configuran estos proyectos, y cómo utilizar su estructura modular para añadir componentes que aportarán funcionalidades a nuestras aplicaciones. Revisaremos muchas características que esta infraestructura proporciona a los frameworks de mayor abstracción como MVC: logging, caching, sessions, settings de aplicación, archivos estáticos, autenticación, etc.
Tras ello, nos tomaremos un pequeño respiro para presentar ASP.NET Core MVC, y volveremos al frente de batalla haciendo una pequeña incursión en el desarrollo con este framework. El objetivo en este punto es proporcionar una visión de alto nivel del funcionamiento de este tipo de aplicaciones que, sin entrar en demasiados detalles, nos permitan comprender sus principales “piezas” (modelo, vistas, controladores) y la forma de trabajar con ellas.
A continuación, recorreremos sucesivamente las capas Modelo, Controlador y Vista, detallando al máximo cómo trabajar con las herramientas que nos proporciona el framework MVC para la creación de aplicaciones web. Estudiaremos en profundidad aspectos como el sistema de routing, binders, validaciones, Razor, helpers, view components, buenas prácticas, uso de patrones…
También tendremos tiempo para profundizar en el desarrollo de servicios o APIs HTTP/REST, consumibles tanto desde aplicaciones web vía Ajax como desde sistemas externos, utilizando para ello las nuevas y potentes características de negociación de contenidos y binding selectivo.
Por último, tras ver algunos otros aspectos como el uso de áreas, Razor Pages, la creación de tests o la internacionalización de aplicaciones presentaremos BlogMachineCore, una la aplicación de ejemplo en la que podrás ver implementadas muchas características vistas en el curso, cuyos detalles puedes leer en este artículo de CampusMVP: arquitectura desacoplada, inyección de dependencias, uso de DTOs, autenticación y autorización, áreas, asincronía, URL amigables, tag helpers, Ajax, páginas de error personalizadas, etc.
Se trata de un completo temario en el que hemos intentado no dejar nada por detrás. El objetivo es que al finalizar el curso estés en disposición de utilizar ASP.NET Core MVC en tus proyectos profesionales y dar el salto definitivo a las tecnologías “Core”.
Para saber más, puedes ver la ficha completa del curso en la web de CampusMVP.
¿Es este curso para mí?
Como seguro sabrás, ASP.NET Core MVC no es la siguiente versión del framework ASP.NET MVC. Se trata de un reboot en toda regla de la tecnología, que de hecho empezó nuevo desde su versión 1.0 con la intención de convertirse en el mejor framework para el desarrollo de aplicaciones y servicios web, aportando importantes características, algunas de ellas impensables hace sólo unos meses en la pila de tecnologías de Microsoft, como el ser multiplataforma, alto rendimiento, escalabilidad, orientación a la nube, libertad de herramientas de desarrollo, etc.La oleada de tecnologías "Core" es probablemente el cambio más drástico que hemos sufrido los desarrolladores ASP.NET desde sus inicios, allá por el año 2002.Pero claro, para conseguirlo han tenido que romper muchas cosas, comenzando por las bases. El nuevo framework MVC corre sobre la nueva infraestructura ASP.NET Core que, de la misma forma, ha sido reescrita desde cero y replanteada para dar cabida a los nuevos requisitos.
Por tanto, si vienes de trabajar con frameworks basados en versiones de ASP.NET iguales o anteriores a 4.x, para saltar a ASP.NET Core tendrás que olvidar muchas de las cosas que ya sabes y aprender a manejar la nueva infraestructura, que ha cambiado radicalmente. Una vez teniendo controlados los cimientos, ya podrás pasar a aprender tecnologías con un nivel de abstracción superior, como el proporcionado por el nuevo framework MVC.
En MVC, a primera vista parece que han cambiado menos cosas, puesto que conceptualmente siguen manteniéndose aspectos que ya se han demostrado válidos en las versiones anteriores del framework. Seguiremos teniendo componentes como controladores, acciones, binding o filtros y continuaremos usando sintaxis Razor para escribir las vistas, pero la práctica totalidad de características ha sufrido cambios.
Aparte, hay novedades muy interesantes como view componentes o tag helpers, el nuevo enfoque para desarrollar APIs HTTP, o las derivadas de la adopción de ASP.NET Core, como el uso de variables de sesión, inyección de dependencias, la autorización o internacionalización, por citar sólo algunas.
Todos estos cambios son los que hacen que este curso sea especialmente interesante, puesto que te permitirá aprender todo lo necesario para dominar primero la nueva plataforma ASP.NET Core, y luego el framework MVC, de forma estructurada y partiendo desde cero. Por tanto, resumidamente;
- Primero, independientemente de las tecnologías con las que hayas trabajado anteriormente, en el curso aprenderás a manejar con solvencia la nueva infraestructura ASP.NET Core.
- Y después, dependiendo de tu punto de partida:
- Si no has trabajado antes con MVC, aprenderás desde cero a construir aplicaciones basadas en el framework MVC sobre la infraestructura ASP.NET Core
- Si has trabajado antes con MVC <=5, aunque te sonarán muchos conceptos, el curso también te será útil porque aprenderás:
- Los cambios en características que ya conocías.
- Cómo afecta la introducción de ASP.NET Core al desarrollo de aplicaciones con el framework MVC.
- Y todas las novedades específicas del framework MVC, que no son pocas.
- Si ya conoces algo de ASP.NET Core pero lo has aprendido “de oídas” o de forma desestructurada, quizás el curso también podría resultarte interesante porque te ofrecerá una visión ordenada y profunda de esta tecnología.
¿Qué conocimientos previos necesito para seguir el curso?
Obviamente, al tratarse de un curso sobre una tecnología web, lo primero que necesitarás conocer, al menos a un nivel básico, es HTML, CSS y Javascript.También es importante comprender las bases del funcionamiento de las aplicaciones web, es decir, saber identificar cliente y servidor, entender las responsabilidades de cada uno de estos extremos y conocer mínimamente los mecanismos de comunicación entre ellos, básicamente el protocolo HTTP. Si has trabajado antes con alguna tecnología de desarrollo para la web (ASP, ASP.NET Web Forms, MVC, PHP, Express…), probablemente ya conozcas todo lo necesario de estos aspectos.
También debes tener un cierto nivel de programación con .NET y C#. Por ejemplo, en el curso no vamos a explicar conceptos básicos como qué es una clase o una interfaz, ni otros aspectos del lenguaje como expresiones lambda, métodos extensores, tipos anulables, o tipos genéricos; se supone que todo eso debes conocerlo ya. Tampoco explicaremos qué es un
List<T>
o un StringBuilder
, son piezas del framework con las que ya debes haber trabajado antes.Aunque no es absolutamente imprescindible para completar el curso, sí que es totalmente recomendable conocer tecnologías de acceso a datos, pues para construir aplicaciones web que jueguen con datos seguro que vas a necesitarlas. A lo largo del temario veremos algunos ejemplos de uso de Entity Framework Core, pero no profundizaremos en ellos al escapar del objetivo del curso.
Por último, indicar que el curso comienza de cero en lo relativo al framework ASP.NET Core y MVC, por lo que en ningún momento se asume que tienes conocimientos en versiones anteriores de ASP.NET, ASP.NET Core u otras tecnologías concretas de desarrollo de aplicaciones web. Sin embargo, si las conoces tendrás algo de ventaja porque podrás "mapear" mentalmente algunos conceptos al nuevo framework y te costará mucho menos trabajo aprenderlos.
¿Y qué ocurre con MVC 5 y los demás frameworks basados en ASP.NET 4.x?
ASP.NET 4.x y los frameworks que descansan sobre él, como Web Forms, MVC, Web API o SignalR, continuarán siendo soportados e incluso podrán ser evolucionados ligeramente, por lo que su vida previsiblemente aún será larga. Hay muchas aplicaciones creadas con estos marcos de trabajo que durante mucho tiempo necesitarán mejoras, ampliaciones o mantenimiento, por lo que siguen siendo opciones razonables a día de hoy e incluso en determinados escenarios pueden ser idóneos para aplicaciones nuevas.Oficialmente, Microsoft recomienda seguir utilizando tecnologías basadas en ASP.NET 4.x para aplicaciones existentes y ASP.NET Core 2.0 para aplicaciones nuevas.Sin embargo, muy probablemente no veremos nunca nuevos productos versionados como ASP.NET 5, MVC 6 o Web API 3, puesto que la apuesta de Microsoft está principalmente centrada en la familia tecnológica "Core": .NET Core, ASP.NET Core, ASP.NET Core MVC y otros frameworks que irán apareciendo. Por tanto, la adopción de estas nuevas tecnologías de forma global es sólo cuestión de tiempo.
Y ya, sé que no es muy científico ni tiene validez para probar gran cosa, pero ahí os dejo una consulta rápida a Google Trends sobre las tendencias actuales de búsqueda sobre distintos "sabores" de ASP.NET, que os puede dar una idea del interés que está despertando el nuevo framework y por dónde pueden ir los tiros en el futuro:
Si por cualquier motivo debes aprender ASP.NET MVC 5, recuerda que en CampusMVP también tenemos un curso apropiado para tí ;) Pero recuerda que sólo una parte de los conocimientos que adquieras serán válidos cuando saltes a ASP.NET Core MVC más adelante.
Me convence, ¿cuándo empezamos?
Pues cuando tú quieras :) Sólo tienes que visitar la web de CampusMVP, inscribirte, y casi sobre la marcha te facilitarán las credenciales de acceso a la plataforma.Y bueno, pues creo que con esto quedarán despejadas todas vuestras dudas sobre el curso, o al menos muchas de ellas. Si no es así, no dudéis en contactar con CampusMVP, donde seguro os atenderán de maravilla, o conmigo a través de un comentario, correo electrónico, o el formulario de contacto del blog.
¡Espero veros a muchos por allí!
Publicado en Variable not found.
Publicado por José M. Aguilar a las 8:55 a. m.
Etiquetas: aspnetcore, aspnetcoremvc, autobombo, curso
lunes, 18 de septiembre de 2017
Pues sí, amigos, ¡ya estamos de vuelta! Como el amigo Gustavo se encarga de recordarme todos los años, el regreso se estaba retrasando demasiado. Y no por falta de ganas, sino porque andaba enfrascado en un proyecto del que pronto tendréis noticia :)
Pero bueno, para empezar la temporada con buen pie, nada como unos cuantos enlaces, que, como siempre, espero que os resulten interesantes. :-)
Pero bueno, para empezar la temporada con buen pie, nada como unos cuantos enlaces, que, como siempre, espero que os resulten interesantes. :-)
.NET/.NET Core
- Managing Secrets in .NET CORE 2.0 Apps
- Michael Hansen
- Experiments in Open Source: Exploring vcr-sharp for Http record and playback
Scott Hanselman - Using Task with .NET Core 2.0 (Success, Error, Cancellation)
Jeremy Bytes - Demystifying .NET Core and .NET Standard
Immo Landwerth
martes, 18 de julio de 2017
Pues sí, por fin llegó el verano, esa época en la que durante unos días podemos cambiar nuestra silla de oficina por una hamaca, y nuestro pequeño monitor por un bonito atardecer en la playa en formato panorámico :)
Por mi parte, intentaré hacer una parada completa de un par de semanas comenzando el próximo lunes, y después volveré al tajo, aunque intentado que sea de forma menos intensa que de costumbre. En lo relativo al blog, supongo que volveré a tomar los mandos ya entrado septiembre; hasta ese momento lo dejo en vuestras manos, así que ¡cuidádmelo! ;)
Imagen: Costaballena - Minube.com
Espero que cuando os llegue el turno paséis unas felices vacaciones y descanséis, siempre en buena compañía. Aprovechad para formatearos mentalmente y recargar pilas para la temporada 2017-18 que, como siempre, promete ser apasionante.
Pero eso sí, recordad que a la vuelta estaremos por aquí de nuevo, buscando la variable :)
Publicado en Variable not found.
Por mi parte, intentaré hacer una parada completa de un par de semanas comenzando el próximo lunes, y después volveré al tajo, aunque intentado que sea de forma menos intensa que de costumbre. En lo relativo al blog, supongo que volveré a tomar los mandos ya entrado septiembre; hasta ese momento lo dejo en vuestras manos, así que ¡cuidádmelo! ;)
Imagen: Costaballena - Minube.com
Espero que cuando os llegue el turno paséis unas felices vacaciones y descanséis, siempre en buena compañía. Aprovechad para formatearos mentalmente y recargar pilas para la temporada 2017-18 que, como siempre, promete ser apasionante.
Pero eso sí, recordad que a la vuelta estaremos por aquí de nuevo, buscando la variable :)
Publicado en Variable not found.
lunes, 17 de julio de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET/.NET Core
- The week in .NET – Links!
Bertrand Le Roy - Memory Usage Inside the CLR
Matt Warren - Pooling large arrays with ArrayPool
Adam Sitnik - .NET Framework July 2017 Security and Quality Rollup
Rich Lander - Virtual Panel: High Performance Application in .NET
Pierre-Luc Maheu - Mapping Complex types to/from JSON with JSON.Net
Eli Weinstock-Herman - Working with “Big Data” in .NET
Eric Law - Send Mail Using SendGrid In .NET Core
Anuraj Parameswaran - Unleashing the Power of .NET Big Memory and Memory Mapped Files
Dmitriy Khmaladze - Good citizenship - logging from .NET libraries
Nicholas Blumhardt - Announcing PostSharp 5.0 RTM
Iveta Moldavcuk - Join Null Check with Assignment Colin Angus Mackay
- Span
Adam Sitnik
martes, 11 de julio de 2017
En C# siempre hemos podido enviar a métodos parámetros por referencia usando la palabra clave
Un ejemplo clásico es el uso de
Veamos en qué consisten.
ref
. Aunque su alcance era algo limitado, nos permitía coquetear con punteros para cubrir de forma eficiente algunos escenarios y permitirnos algunos usos avanzados, pero sin necesidad de abandonar la seguridad que nos ofrece el entorno de ejecución de .NET.Un ejemplo clásico es el uso de
ref
para intercambiar dos valores desde un método:int one = 1, two = 2; Swap(ref one, ref two); Console.WriteLine($"{one},{two}"); // 2,1 ... void Swap<T>(ref T a, ref T b) { var temp = a; a = b; b = temp; }En C#7, el ámbito de uso de las referencias se ha ampliado bastante gracias a la introducción de dos nuevas características en el lenguaje:
- El soporte para variables locales de tipo referencia, o ref locals.
- La capacidad de un método o función de retornar referencias, también conocida como ref returns.
Veamos en qué consisten.
lunes, 10 de julio de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET/.NET Core
- The week in .NET – Links!
Bertrand Le Roy - Porting a 15 year old .NET 1.1 Virtual CPU Tiny Operating System school project to .NET Core 2.0
Scott Hanselman - .NET Core solution management via the command line interface
Joseph Woodward - Debouncing and Throttling Dispatcher Events
Rick Strahl - ConcurrentDictionary allocates … a lot
Rick Brewster - Estrategias para controlar las excepciones en C#
Albert Capdevila - C# 7 Series, Part 4: Discards
Mark Zhou - When you use the Polly circuit-breaker, make sure you share your Policy instances!
Andrew Lock
martes, 4 de julio de 2017
Poco a poco seguimos desmenuzando las novedades disponibles tras la llegada de C# 7. Hasta el momento hemos visto las siguientes:
En esta ocasión veremos un par de pequeñas adiciones al lenguaje que, aunque de mucho menor calado de otras que ya hemos repasado, también merecen tener su minutillo de protagonismo ;)
En esta ocasión veremos un par de pequeñas adiciones al lenguaje que, aunque de mucho menor calado de otras que ya hemos repasado, también merecen tener su minutillo de protagonismo ;)
lunes, 3 de julio de 2017
Tras el subidón de mi séptimo nombramiento como MVP, seguimos con las tradiciones, así que ahí van los enlaces recopilados durante la semana pasada. Como de costumbre, espero que os resulten interesantes. :-)
.NET/.NET Core
- The week in .NET – .NET Conf, Material Design in XAML Toolkit
Bertrand Le Roy - Sobre NuGet y versiones…
Eduard Tomás - .NET Core: Finding out SDK-, installed runtime-, and Framework Host versions
Iris Classon - Announcing .NET Core 2.0 Preview 2
Rich Lander - Speed of dotnet run vs the speed of dotnet for published apps (plus self-contained .NET Core apps)
Scott Hanselman - Hashing, Encryption and Random in ASP.NET Core
Paul Hiles - Installing Additional App Templates for dotnet new
Steve Smith - Exploring CQRS within the Brighter .NET open source project
Scott Hanselman - .NET Framework June 2017 Cumulative Quality Update for Windows 10
Rick Lander - Performance Improvements in RyuJIT in .NET Core and .NET Framework
Joseph Tremoulet - C# Goes Back to BASICs with Local Functions
Tim Patrick - Generate C# API Documentation with Wyam
Derek Comartin
Estimados amigos, simplemente quería compartir con vosotros una alegría. Como viene ocurriendo desde hace siete años, he vuelto a ser honrado recibiendo el galardón MVP de Microsoft por mis contribuciones a la comunidad durante el año pasado.
Aunque ya vayan siendo siete los galardones y quizás debería haberme acostumbrado un poco, no es así. Sigo sintiendo la misma mezcla explosiva de satisfacción, orgullo y alegría al recibir la tradicional notificación por email:
Me siento feliz de poder continuar estando cerca de este grupo de frikis que dedican parte de su tiempo a compartir conocimientos y aportar para que muchos podamos mejorar cada día subidos a hombros de gigantes. Y es todo un lujazo poder tener entre ellos a grandes amigos, porque, aparte de ser técnicamente brillantes, me he encontrado ahí con unas personas excepcionales.
Mi eterno agradecimiento al equipo del programa MVP en Microsoft, a la gran Cristina González, nuestra MVP lead, y a todos vosotros, amigos de Variable not found, porque al fin y al cabo sois los que hacéis posible que pueda sentirme tan afortunado.
Aprovecho también para dar la enhorabuena al resto de MVP nombrados el mismo día, ya sea por primera vez o renovando galardón.
Por último, me gustaría enviar un afectuoso abrazo para grandes amigos que este año han abandonado el programa (espero que temporalmente), pero que seguro seguirán dando caña con y para la comunidad porque ellos lo valen ;) ¡Aúpa chicos!
Publicado en Variable Not Found.
Aunque ya vayan siendo siete los galardones y quizás debería haberme acostumbrado un poco, no es así. Sigo sintiendo la misma mezcla explosiva de satisfacción, orgullo y alegría al recibir la tradicional notificación por email:
Me siento feliz de poder continuar estando cerca de este grupo de frikis que dedican parte de su tiempo a compartir conocimientos y aportar para que muchos podamos mejorar cada día subidos a hombros de gigantes. Y es todo un lujazo poder tener entre ellos a grandes amigos, porque, aparte de ser técnicamente brillantes, me he encontrado ahí con unas personas excepcionales.
Mi eterno agradecimiento al equipo del programa MVP en Microsoft, a la gran Cristina González, nuestra MVP lead, y a todos vosotros, amigos de Variable not found, porque al fin y al cabo sois los que hacéis posible que pueda sentirme tan afortunado.
Aprovecho también para dar la enhorabuena al resto de MVP nombrados el mismo día, ya sea por primera vez o renovando galardón.
Por último, me gustaría enviar un afectuoso abrazo para grandes amigos que este año han abandonado el programa (espero que temporalmente), pero que seguro seguirán dando caña con y para la comunidad porque ellos lo valen ;) ¡Aúpa chicos!
Publicado en Variable Not Found.
martes, 27 de junio de 2017
Hace poco hablábamos del nuevo soporte para tuplas de C#, y comentábamos que una forma de consumirlas era mediante la deconstrucción, otra nueva característica introducida en la versión 7 del lenguaje, que consiste en “despiezar” las tuplas, extrayendo de ellas sus elementos e introduciéndolos en variables locales, utilizando una sintaxis muy concisa.
En realidad no es algo demasiado diferente a lo que hacemos normalmente cuando almacenamos en una variable local el resultado de un método que retorna un único valor:
En realidad no es algo demasiado diferente a lo que hacemos normalmente cuando almacenamos en una variable local el resultado de un método que retorna un único valor:
// Guardamos el valor de retorno en variable local var sum = Sum(1, 3); Console.WriteLine($"Sum: {sum}"); ... static int Sum(int a, int b) { return a+b; }
lunes, 26 de junio de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET/.NET Core
- The week in .NET – .NET Architecture: Microservices & Containers, On .NET with Omer Raviv on OzCode, Sprache
Bertrand Le Roy - Multi-Targeting and Porting a .NET Library to .NET Core 2.0
Rick Strahl - Mocking in .NET Core Tests with Moq
Jason Roberts - Abolishing Switch-Case Statement and Pattern Matching in C# 7.0
Nikola Živković - Perks of using UI for ASP.NET MVC
Matt Millican - Four ways to dispose IDisposables in ASP.NET Core
Andrew Lock - High-performance .NET by example: Filtering bot traffic
Alexandr Nikitin - Consuming Google.Apis.Sheets.V4 Services From C#
Tapan Kumar - C# - Make C# More Dynamic with Hyperlambda
Thomas Hansen - Understanding & Profiling C# Async Await Tasks
Matt Watson
martes, 20 de junio de 2017
Continuamos esta serie sobre las novedades incluidas en C#7, y en esta ocasión vamos a ver una pequeña mejora en el lenguaje que seguro nos será de utilidad para simplificar código muy frecuente: las expresiones throw.
Fijaos en un código como el siguiente, que seguro que habéis escrito cientos de veces, donde utilizamos el constructor de una clase para recibir sus dependencias y almacenarlas en miembros de la instancia:
Fijaos en un código como el siguiente, que seguro que habéis escrito cientos de veces, donde utilizamos el constructor de una clase para recibir sus dependencias y almacenarlas en miembros de la instancia:
public class MyService: IMyService { private readonly IDependency _first; private readonly IAnotherDependency _second; public MyService(IDependency first, IAnotherDependency second) { if (first==null) throw new ArgumentNullException("first"); if (second == null) // O mejor, usando el operador nameof throw new ArgumentNullException(nameof(second)); _first = first; _second = second; } ... }
lunes, 19 de junio de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET/.NET Core
- The week in .NET – On .NET with Mattias Karlsson on Cake, Topshelf
Bertrand Le Roy - How to reference a .NET Core library in WinForms - Or, .NET Standard Explained
Scott Hanselman - How the .NET Runtime loads a Type
Matt Warren - Creating your first shared library in .NET Core
Paul Hiles - My Favorite C# 7 Feature: More expression-bodied members
James Montemagno - The TDLR; on easily managing .NET concurrent asynchronous threads
Michael Ballhaus - Hangfire: Task Scheduler for .NET
Ilya Chumakov - C# 7.x and 8.0: Uncertainty and Awesomeness
Erik Heemskerk - Calling Web Services with HttpWebRequest, WebClient and HttpClient
Peter Vogel - Automate Testing and Running Apps with dotnet watch
Steve Smith - Viva, Visual Basic! Or, Does VB Have a Future?
Michael Domingo - Visual Basic and Cross-Platform: Mobile Apps with VB, Xamarin, and .NET Standard!
Klaus Löffelmann - Microsoft .NET Framework 4.7 is available on Windows Update, WSUS, and MU Catalog
Jamshed Damkewala - How to build / publish self contained .NET Core binaries for Windows, Linux and OSX
Christophe Diericx - AutoMapper 6.1.0 released
Jimmy Bogard
martes, 13 de junio de 2017
Y continuamos escarbando en las nuevas características disponibles en C#7, incluido de serie en Visual Studio 2017. Hasta el momento hemos profundizado en las siguientes novedades:
En esta ocasión nos centraremos en la vuelta de tuerca que se ha dado a las tuplas a nivel de lenguaje, reforzándolas como first-class citizens para los desarrolladores C#.
En esta ocasión nos centraremos en la vuelta de tuerca que se ha dado a las tuplas a nivel de lenguaje, reforzándolas como first-class citizens para los desarrolladores C#.
lunes, 12 de junio de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET/.NET Core
- The week in .NET – On .NET with Brett Morrison, DateTime Extensions
- Bertrand Le Roy
- Performance Improvements in .NET Core
Stephen Toub - Top .NET Software Errors: 50 Common Mistakes and How to Fix Them
Angela Stringfellow - Building the Ultimate RestSharp Client in ASP.NET and C#
Matthew Jones - An Early Look at C# 7.1: Part 1
Jonathan Allen - C# 7.1 and Beyond: Polishing Usability
Erik Heemskerk - Retaining (and altering) key functions when using Console.ReadKey()
Jasper Lammers - Iterators in C#: yield, IEnumerable & IEnumerator
Alan Zucconi - C# 7 Series, Part 3: Default Literals
Mark Zhou - Trying .NET Core on Linux with just a tarball (without apt-get)
Scott Hanselman - C# 7.2 and 8.0 Roadmap
Jonathan Allen
martes, 6 de junio de 2017
Cuando desarrollamos aplicaciones web que funcionan sobre el protocolo HTTPS en la máquina local, lo más habitual es que utilicemos un certificado digital autofirmado o, en cualquier caso, firmado por una entidad no confiable.
Esto hace que los navegadores, por supuesto siempre con el ánimo de preservar nuestra privacidad, sospechen del sitio web y muestren alertas como la siguiente, donde se nos informa de que el certificado es inválido y que alguien podría estar intentando robarnos información:
Esto hace que los navegadores, por supuesto siempre con el ánimo de preservar nuestra privacidad, sospechen del sitio web y muestren alertas como la siguiente, donde se nos informa de que el certificado es inválido y que alguien podría estar intentando robarnos información:
lunes, 5 de junio de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET/.NET Core
- The week in .NET – Open XML SDK, Adventure Time
Bertrand Le Roy - .NET Core - Cross-Platform Code Generation with Roslyn and .NET Core
Alessandro Del Sole - C# 7 Series, Part 2: Async Main
Mark Zhou - The Fraternal Twins of Equals and GetHashCode
Tim Patrick - .NET Standard, una librería para dominarlos a todos
Diego Bersano - Array Pool
Christian Nagel - The Coming .NET Renaissance
Aaron Stannard - Integration testing with .NET Core
Dmitriy Litichevskiy
miércoles, 31 de mayo de 2017
Hace poco me encontraba con el post "Breakpoint Generator extension is open source" y me llamó la atención, básicamente porque no sabía de qué estaban hablando. Cosas de la ignorancia :D
Tirando un poco del hilo, he encontrado con que se trata de una extensión interesante y que podría ser útil en algunos escenarios, por lo que voy a comentar por aquí lo que he ido viendo.
Tirando un poco del hilo, he encontrado con que se trata de una extensión interesante y que podría ser útil en algunos escenarios, por lo que voy a comentar por aquí lo que he ido viendo.
martes, 30 de mayo de 2017
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
.NET/.NET Core
- The week in .NET – .NET poster, Happy Birthday .NET with Jan Kotas, Skyworld
Bertrand Le Roy - Using .NET and Docker Together
Rich Lander - Working with Exceptions Before the Error Handler Does
Peter Vogel - Aspects of Strings in .NET
Timur Guev - .NET Framework May 2017 Cumulative Quality Update for Windows 10
Rick Lander - Experimenting with C# 7’s new features
Afzaal Ahmad Zeeshan - How to Send Email using .NET Core
Ben Cull - How do I Update a Nuget Package using dotnet CLI
Steve Smith - AsyncLock: an async/await-friendly locking library for C# and .NET
Neosmart Technologies - IEnumerable vs IReadOnlyList
Vladimir Khorikov - El patrón Singleton en C#
Albert Capdevila
martes, 23 de mayo de 2017
El amigo José Antonio M. A., alumno de mi curso de ASP.NET MVC 5 en CampusMVP, me envió hace unos días una pregunta que he creído interesante comentar por aquí porque probablemente pueda ayudar a alguien más.
La cuestión que planteaba era relativa al mal funcionamiento de WebGrid cuando mostramos un campo de tipo enum y queremos ordenar por el mismo. Poco más o menos, me lo comentaba de la siguiente forma:
Mis primeras respuestas iban orientadas a buscar un pequeño fallo en la forma de usar WebGrid o similar, porque me parecía algo bastante extraño, y, sobre todo, me parecía raro que no me hubiera pasado antes. José Antonio comentó, además, que había encontrado referencias por la red de que WebGrid tenía este problema, y que podía solucionarse si se forzaba una conversión de la enumeración a
Y tras hacer varias pruebas, efectivamente, parece que algo hay. No sé si categorizarlo como bug del componente, o simplemente un comportamiento algo oscuro y poco previsible del mismo, pero en cualquier caso es interesante conocer este problema para poder atajarlo con éxito.
La cuestión que planteaba era relativa al mal funcionamiento de WebGrid cuando mostramos un campo de tipo enum y queremos ordenar por el mismo. Poco más o menos, me lo comentaba de la siguiente forma:
He incluido un campo enum en la clase del modelo y lo he incluido como columna en WebGrid.Obviamente, el hecho de que al cambiar a mano el parámetro
[…]
Todo funciona bien menos el WebGrid, que no me ordena por esa columna. Al hacer click en ella ordena de forma correcta ascendentemente pero al hacer click otra vez no te ordena de forma descendente, mirando la url se ve que sortOrder no varía sigue siendo ASC. si lo cambio a mano a desc me lo ordena bien. ¿Es que el webgrid no ordena enumeraciones? ¿Cuál sería la solución, si quiero ordenar?
sortOrder
todo funcionara bien, dejaba de manifiesto que el problema no estaba en el controlador ni en el modelo, dejando la vista como única sospechosa de provocar ese problema.Mis primeras respuestas iban orientadas a buscar un pequeño fallo en la forma de usar WebGrid o similar, porque me parecía algo bastante extraño, y, sobre todo, me parecía raro que no me hubiera pasado antes. José Antonio comentó, además, que había encontrado referencias por la red de que WebGrid tenía este problema, y que podía solucionarse si se forzaba una conversión de la enumeración a
string
a la hora de pasar los datos a la vista (!).Y tras hacer varias pruebas, efectivamente, parece que algo hay. No sé si categorizarlo como bug del componente, o simplemente un comportamiento algo oscuro y poco previsible del mismo, pero en cualquier caso es interesante conocer este problema para poder atajarlo con éxito.