lunes, 21 de octubre de 2019

Downloading IntelliSense index for nuget.org

I've recently updated my Visual Studio IDE from v.2017 to v.2019.

Since then, a background task was permantly running under the label "Downloading IntelliSense index for nuget.org".
A few entries appear googling the issue, and the official answer always is "update to the latest version and try again". And obviously, that doesn't work. 

Then, I've found this entry from Lars Wilhelmsen:

Create an DWORD (32-bit) value called Enabled and set it to 0 under:
HKCU\SOFTWARE\Microsoft\VisualStudio\16.0_6cf1d688\Roslyn\Features\SymbolSearch
The 'Roslyn\Features\SymbolSearch' keys have to be created as well. The '16.0_6cf1d688' version number might be different on your machine.

And magically, the problem is solved.

martes, 1 de octubre de 2019

MVVM with SQLite: solution model

When implementing some design pattern or architecture that requires some concentration and learning from me, I like to document the process to have it as a reference in the future, and also to share it with others who want to travel the same path.

In this case, it's about how I applied the Model-View-ViewModel pattern along with SQLite persistence data, in my mobile application developed with Xamarin Forms.

I will just list the high-level steps of the process, which is illustrated in the class diagram below. It should be clarified that the diagram only reflects those attributes and behaviors of the class model that I consider relevant for the explanation, because, clearly, the complete model is much more extensive.

On the one hand I added an ExtendedBindableObject class, which derives from BindableObject, and adds the automatic notification of the PropertyChanged event, when a ViewModel undergoes some change in its exposed properties.

From the ExtendedBindableObject class, derive BaseViewModel, which will serve as the basis for all the ViewModels of each object to represent.

The ViewModels scheme in my case, speaking for now for simple objects, consists of a ViewModel with a collection of objects, another to add new objects, and another one to show the details of a given object, which also allows you to delete or modify its attributes.

For each of the ViewModels detailed above, a View corresponds, implemented within the Xamarin Forms model as a ContentPage.

When the View is created, the corresponding ViewModel constructor is called, and a new instance of the CrudService service (which implements the ICrudService interface) is passed, which the ViewModel contains. In this way, the dependency injection pattern is used (a particular case of the control inversion pattern) indicating to the ViewModel what service to use to access the data layer.

The CrudService service, in turn, is responsible for making calls to the data layer, represented by the AppDatabase class.

This is roughly the complete picture needed to implement MVVM together with SQLite. I had to spend several hours reading, and then testing, until it was working, but it leaves me happy to be aligned with the recommended practices.

If the promise of scalability and cleaner growth of the application, which this pattern proposes, is fulfilled, time will tell.

MVVM con SQLite: modelo de solución

Cuando implementar algún patrón de diseño o un arquitectura que requiere cierta concentración y aprendizaje de mi parte, me gusta documentar el proceso para tenerlo como referencia en el futuro, y también para compartirlo con otros que quieran transitar el mismo camino.

En este caso, se trata de cómo apliqué el patrón Model-View-ViewModel junto con persistencia de datos SQLite, en mi aplicación móvil desarrollada con Xamarin Forms.

Me limitaré a enumerar lo pasos a alto nivel del proceso, que queda ilustrado en el diagrama de clases que acompaña el artículo. Cabe aclarar, que el diagrama sólo refleja aquellos atributos y comportamientos del modelo de clases que considero relevantes para la explicación, porque, claramente, el modelo completo es mucho más extenso.

Por un lado agregué una clase ExtendedBindableObject, que deriva de BindableObject, y agrega la notificación automática del evento PropertyChanged, cuando un ViewModel sufre algún cambio en sus propiedades expuestas.

De la clase ExtendedBindableObject, deriva BaseViewModel, que servirá de base para todas los ViewModels de cada objeto a representar.

El esquema de ViewModels en mi caso, hablando por ahora para objetos simples, consta de un ViewModel con una colección de objetos, otro para agregar nuevos objetos, y otro más para mostrar los detalles de un objeto dado, que además permite borrar o modificar sus atributos.

Para cada uno de los ViewModels detallados anteriormente, se corresponde un View, implementado dentro del modelo de Xamarin Forms como un ContentPage.

Al momento de crearse el View, se llama al constructor del ViewModel correspondiente, y se le pasa una nueva instancia del servicio CrudService (que implementa la interfaz ICrudService), que el ViewModel contiene. De este modo, se hace uso del patrón de inyección de dependencias (un caso particular del patrón inversión de control) indicando al ViewModel qué servicio utilizar para acceder a la capa de datos.

El servicio CrudService a su vez, se encarga de hacer las llamadas a la capa de datos, representada por la clase AppDatabase.

Esto es a grandes rasgos el cuadro completo necesario para implementar MVVM junto con SQLite. Tuve que invertir varias horas de lectura, y luego de pruebas, hasta dejarlo funcionando, pero me deja conforme estar alineado con las prácticas recomendadas.

Si se cumple luego la promesa de escalabilidad y crecimiento más limpio de la aplicación, que este patrón propone, el tiempo dirá.


sábado, 28 de septiembre de 2019

Workout.Me: Localización y Messaging Center


Fue realmente simple de implementar la localización.

Por el momento me limité a definir algunos strings en dos archivos de recursos, uno en inglés y otro en español.

Para probar el funcionamiento, agregué un ítem de menú en el Flyout para intercambiar entre idiomas, y desde allí se envía un mensaje multicast con el MessagingCenter:



Tan simple como ejecutar una línea de código:

MessagingCenter.Send<AppShell>(this, "LanguageChanged");

Y luego, desde cada clase que se desee, hay que suscribirse para recibir ese mensaje:

MessagingCenter.Subscribe<AppShell> (this, "LanguageChanged", (sender) =>
{
    //ApplyLanguage();
});


Muy limpio, efectivo, fácil de implementar. Hermoso.

Workout.Me: Localization & Messaging Center

I haven't writing in english for a while.

Today I accomplished a new goal, adding localization for different languages on the Workout.Me app.

It was really easy to do. By the moment I just defined some strings in two resource files, one in english and another in spanish.

To try this feature, I added a menu item to the AppShell flyout, which just do switch the languages. Actually the method, first changes the CultureInfo and then send a multicast message through the MessagingCenter class.



Then simply call the Send method:

MessagingCenter.Send<AppShell>(this, "LanguageChanged");

And then, in each desired class, it's necessary to suscribe to that message:

MessagingCenter.Subscribe<AppShell> (this, "LanguageChanged", (sender) =>
{
    //ApplyLanguage();
});


So clean, effective and easy to implement. Beautiful.

Workout.me : Localización e idiomas

Antes de continuar con el armado del resto de las pantallas, quiero dejar resuelto el tema de los idiomas y la traducción. 

Esto en Xamarin se lleva a cabo con archivos de recursos y luego referenciando estos strings desde el código o el markup xaml. 


domingo, 22 de septiembre de 2019

lunes, 16 de septiembre de 2019

Workout.Me - MVVM

Después de renegar un poco logré implementar un patrón MVVM simple. Una clase del modelo de dominio, un viewmodel, y una vista que hace referencia a éste en su BindingContext.

El ViewModel lo estoy derivando de un ViewModelBase, que a su vez derivo de ExtendedBindableObject. Esta última clase es la que se encarga de lanzar el evento PropertyChanged, que da aviso al View cuando se modifican las propiedades del ViewModel.

Por otro lado, la lista de objetos a mostrarse, el ViewModel la está obteniendo ahora de un servicio, que actualmente genera por código los ítems a mostrar.


Próximos pasos: obtener la lista de ítems accediendo a la capa de datos, y que ésta a su vez los recupere de una base local.

domingo, 15 de septiembre de 2019

Workout.Me - nuevo proyecto

Tal como había adelantado hace unos días, estoy comenzando con un proyecto nuevo, una aplicación móvil.

Por ahora la aplicación, salvo que se me ocurra o aparezca algo mejor, se llamará Workout.Me, y se trata de una herramienta con el objetivo primario de asistir en lo que a entrenamiento se refiere.

La idea es que cuente con varias opciones predefinidas para seleccionar, en cuanto a formas de entrenar, según los objetivos del usuario. Y mucha personalización.

A diferencia de proyectos anteriores donde busqué satisfacer en mayor o menor medida las espectativas del usuario final, en este caso ese usuario final soy yo. Obviamente que vengo repasando e investigando las principales opciones que actualmente hay en mercado, pero mi objetivo principal es que la app tenga todo aquello que busco y que actualmente no estoy encontrando en las aplicaciones disponibles.

El proyecto tiene objetivos múltiples. Por un lado, claro, está la aplicación propiamente dicha. Pero también el aprendizaje. Estoy aprediendo todo lo posible acerca de la tecnología Xamarin, aplicando patrones como MVVM, inyección de dependencias, skins, localización, etc.

Iré narrando los avances y novedades en la sección de blog, bajo la etiqueta workoutme.

Ah, este es el logo:


lunes, 9 de septiembre de 2019

Agilidad Vs. Escalabilidad y Mantenimiento

Vengo leyendo hace rato que en desarrollo mobile está bastante generalizado el patrón MVVM (model - view - viewmodel).

Como la aplicación del proyecto en curso es bastante pequeña, quizás no se justifique el esfuerzo de implementarlo. 

Pero creo que se justifica desde la inversión en conocimiento y en incorporarlo como buena práctica a futuro.

domingo, 8 de septiembre de 2019

Vuelta a la vida!

Después de largo tiempo sin actividad, y luego otro largo tiempo haciendo cosas pero sin publicarlas, vuelvo a darle vida a este blog.

Retomé el desarrollo de aplicaciones móviles.

Había estado unos cuantos meses avanzando con una aplicación android, en Android Studio, y terminé sumamente frustrado por lo dificultoso de lograr algo tan sencillo como compilar la aplicación. Las dependencias y los repositorios de donde se van descargando las mismas, que maven, que gradle, que integración continua, etc. Todo muy lindo salvo cuando estás atrás de un proxy corporativo que te filtra la mitad de internet, y que es imposible de configurar en la IDE.

Como mis pretensiones en cuanto a UI/UX eran modestas, decidí ir por lo seguro y me pasé a Xamarin.Forms. El viejo y conocido Visual Studio, además de no comerse viva la RAM del equipo, es mucho más llevadero de configurar y sacar andando lo que sea.

A la par de esto, quiero retomar también el desarrollo de juegos, y no estoy seguro de qué plataforma será. Quizás Unity, quizás monogame. Veremos.

Próximamente habrá más noticias y avances.