Pues eso… algo tan simple como usar en .NET MAUI una DLL creada a partir de un proyecto del tipo class library, puede ser toda una odisea. Te lo explico para que te quede claro.
Como ya sabrás, puedes crear proyectos del tipo class library para añadirlos como referencia a otros proyectos que usen esa DLL o biblioteca de clases. Algo que es bastante común en cualquier aplicación para .NET ya sea .NET Framework como para .NET a secas incluido los proyectos para aplicaciones móviles con Xamarin.Forms. En estes último, lo que se suele hacer es usar una DLL compilada para .NET Standard. Hasta aquí todo bien.
La idea de usar una biblioteca de clases es para reutilizar el código en proyectos diferentes, es decir, creas la biblioteca de clases con cierta funcionalidad y esa misma biblioteca de clases la utilizas en proyectos diferentes. Al menos si esos tipos de proyectos son compatibles en el sentido de usar el mismo .NET.
Y como ahora estoy haciendo pruebas de Google Cloud Natural Language, pues pensé crear algún proyecto para .NET MAUI que usara esa API. Y como ya tenía el código de ciertas clases creado como proyecto DLL (Class Library) pensé agregar la referencia al proyecto de .NET MAUI y… ¡yaumate! (una expresión de mi zona que quiere decir algo así como… ¡tararí que te vi! o… ¡que te lo has creído!)
¡Y así fue! ¡Me lo creí! Pensaba que en .NET MAUI las cosas seguirían siendo como en el resto de .NET, pero no…
De hecho, hasta creé una class library usando la plantilla de MAUI, pero ni por esas… el proyecto de .NET MAUI nada más que daba errores de que no se podía tener referencia a esas clases definidas en la DLL (o class library).
La solución que tomé fue añadir directamente el código de esas clases en el mismo proyecto de .NET MAUI y así funcionó, pero no era eso lo que yo pretendía, ya que además del proyecto para .NET MAUI tenía otros proyectos: de tipo consola de Windows Forms para C# y Visual Basic y en todos ellos pretendía usar la misma DLL o biblioteca de clases.
Pero la solución buena ha sido creando una DLL (proyecto del tipo Class Library), crear un paquete de NuGet y usar ese paquete como referencia en lugar de una referencia al proyecto de tipo class library.
Decirte que esa referencia, al proyecto, sí que funciona en los proyectos de tipo consola o de tipo Windows Forms, tanto para VB como para C#, pero no si el proyecto es de .NET MAUI.
Te lo explico por si alguna vez te pasa esto… para que no te calientes la cabeza ni pierdas todo el tiempo que yo he perdido.
Y para muestra, el proyecto ElizaNET y el correspondiente Eliza MAUI (los enlaces van al repositorio de GitHub), que ambos usan una DLL compilada para .NET 7.0 y que funcionan a la perfección (salvo los bugs que se puedan producir en esa biblioteca de clases, que algunos pueden surgir).
Esos dos proyectos usan el código publicado en NuGet de Eliza gcnl Library que ahora va por la versión 1.0.2.
El código fuente de esa DLL (o paquete de NuGet) está en este enlace (dentro del repositorio ElizaNET).
Y esto es todo… espero que te sea de utilidad. Esa es la intención.
Pues eso… probando con el código que he hecho con Java (desde el IntelliJ IDEA) he querido compilar el código a .exe, pero no sé cómo hacerlo… solo me he quedado en crear un fichero .jar y ese poder ejecutarlo con el «java» desde la línea de comandos.
Versión de Java instalado
Al intentar hacerlo me he topado con un par de problemas, al menos desde mi máquina con el Visual Studio 2019 instalado (aparte del Visual Studio 2022), aclaro esto porque se ve que el Visual Studio 2019 tiene instalada una versión del JDK más antigua, concretamente la versión 1.8.0_302 y el código que he usado en las pruebas con records y expresiones swicht necesita al menos el JDK 17 (JDK = Java Development Kit).
Para poder usar el código que he publicado en varios de los repositorios (y los gists) de GitHub, instalé el JDK 19 (el último a la hora de escribir esto y también cuando empecé a hacer las pruebas en noviembre), pero la versión del JDK que está primero en la variable PATH es la carpeta bin de la versión 1.8, por tanto, al usar cualquiera de los comandos de Java (java para ejecutar los .jar o javac para compilar el código) me daba error.
Cuando se instala el JDK (al menos desde Visual Studio) se crea una variable de entorno que se llama JAVA_HOME con el path del directorio donde está instalado el JDK de Java. En mi equipo el path indicado es: C:\Program Files\Microsoft\jdk-11.0.12.7-hotspot. Que como te puedes imaginar es la versión 11 del JDK. Esa versión tampoco soporta las expresiones swicht ni los records (aunque sí los tipos genéricos).
Así que… la solución es instalar un JDK que soporte esas dos «cosillas» que necesito en mi código.
Instalar un nuevo JDK de Java
Como la última versión que hay actualmente es la 19, esa es la que descargué (desde el propio IDE de IntelliJ IDEA), pero que puedes descargar desde la página de OpenJDK.
A fecha de hoy (27 de noviembre) el último JDK de Java es el 19, pero también puedes descargar versiones anteriores, aunque… ¿para qué? si con el último te aseguras que lo tienes todo 😉 Quiero comentarte que desde esa página puedes descargar la versión del JDK para distintos sistemas operativos. En mi caso descargué el de Windows.
Si quieres usar otra versión anterior, por ejemplo, la implementación del Java SE 17 también valdría, puedes hacerlo desde los enlaces de la parte izquierda de la página del enlace que te he puesto en el párrafo anterior.
Para usarlo, te descargas el zip, lo extraes en una carpeta (normalmente en la carpeta .jdks del directorio de %USERPROFILE% (la carpeta predeterminada del usuario de Windows).
En mi caso, ahí tengo el JDK 19 (instalado por IntelliJ IDEA) y el JDK 17 que me lo descargué para comprobar que con esa versión también funciona.
Lo que hice a continuación es añadir variables de entorno para acceder fácilmente a esos directorios, concretamente he creado dos variables de entorno, una para el JDK 19 y otra para el JDK 17.
Para hacer esto, abre las opciones avanzadas del sistema (Advanced System Settings) y acceder a las variables de entorno (Environment Variables). Para acceder, pulsa con el botón secundario en This PC > Settings y en el panel derecho (estoy usando Windows 11) pulsa en Advanced System Settings o bien en buscar escribe «Advanced System Settings» o desde la línea de comandos (o desde run) escribe control sysdm.cpl y selecciona la ficha «Advanced»
Una vez tengas las variables de entorno (ver la figura 1), pulsa en el botón New de la parte superior y en el cuadro de diálogo escribe JAVA_HOME19 y en el path escribe el directorio en el que está ese JDK, en mi caso escribí %USERPROFILE%\.jdks\openjdk-19.0.1 y después se puso el path que corresponde.
Figura 1. Las variables de entorno
No es necesario que pongas los dos paths a los dos JDK, yo solo los he puesto para comprobar que la versión 17 también servía.
Una vez que tengas esto, abre la terminal o la línea de comandos y escribe %JAVA_HOME19%\bin\java --version para comprobar la versión del JDK de Java instalado.
Microsoft Windows [Version 10.0.22000.1281]
(c) Microsoft Corporation. All rights reserved.
C:\Users\Guille>%JAVA_HOME19%\bin\java --version
openjdk 19.0.1 2022-10-18
OpenJDK Runtime Environment (build 19.0.1+10-21)
OpenJDK 64-Bit Server VM (build 19.0.1+10-21, mixed mode, sharing)
Puedes escribir tanto java --version como java -version, el resultado prácticamente es el mismo, pero no igual; además de que -version se muestra en el stream de error y –version en el stream de salida.
Te aclaro que todo esto es por si el Java que tienes instalado es anterior a la versión 17, cosa que ocurrirá si tienes Visual Studio instalado y has indicado que quieres crear aplicaciones de Xamarin o .NET MAUI que instalan los JDK de Java.
En cualquier caso, antes de ahcer todo lo aquí explicado, comprueba con java -version (sin indicar ningún path y con un solo guión, ya que las versiones anteriores no reconocen el parámetro --version) qué versión tienes y si es la 17 o superior, pues… ¡todo hecho!
En mi caso me muestra esto, así que, necesito instalar un JDK más reciente.
Microsoft Windows [Version 10.0.22000.1281]
(c) Microsoft Corporation. All rights reserved.
C:\Users\Guille>java -version
openjdk version "1.8.0_302"
OpenJDK Runtime Environment (Temurin)(build 1.8.0_302-b08)
OpenJDK 64-Bit Server VM (Temurin)(build 25.302-b08, mixed mode)
Al compilar el código te explicaré para qué he creado la variable de entorno %JAVA_HOME19%, ya que no he querido añadir el path al directorio bin del JDK en la variable de entorno PATH para que no afecte a lo que Visual Studio necesita.
El código de prueba
Para esto que te comentaré en este post, voy a usar el código publicado en el gist Evaluar.java (gist = trozo de código publicado en GitHub).
En ese código, utilizo la expresión switch (no confundir con la sentencia switch) y los records con tipos genéricos para simular una tuple de 2 valores, (tuple = una estructura de datos que consiste en múltiples partes).
Nota: En el lenguaje Java no existe el «tipo tuple» aunque hay implementaciones que, si lo tienen, como por ejemplo JavaTuples de Maven (en esta página puedes ver algunos ejemplos de JavaTuples), pero no en el JDK oficial (al menos a día de hoy).
Como en mi código necesitaba que una función devolviese dos valores, lo simulé con un record de tipo genérico. Este es el código:
/** * Tuple de dos valores para usar al buscar un operador y la posición del mismo. * * @param operador Un valor del tipo T1. * @param position Un valor del tipo T2. * @param <T1> El tipo (por referencia) del primer parámetro. * @param <T2> El tipo (por referencia) del segundo parámetro. */ record TuplePair<T1, T2>(T1 operador, T2 position) {
}
Compilar el código JAVA y crear el fichero .jar
Descarga el fichero ese de prueba, en el que utilizo 3 clases (2 clases y un record) ambos definidos dentro de la clase Evaluar (fichero Evaluar.java) y cópialo en cualquier carpeta de tu equipo.
Todo lo que aquí te explico también serviría si la clase ConsoleColor está definida en un fichero independiente, aunque el record (TuplePair) debe estar definido dentro de la clase Evaluar, ya que se accede directamente a los campos privados del record en vez de a métodos públicos. Esos campos privados son accesibles desde la clase Evaluar porque el record está definido «dentro» de esa clase.
Compilar el código con javac
Para compilar el código usamos javac indicando los ficheros .java a compilar, opcionalmente le podemos indicar en qué directorio queremos que se creen los ficheros compilados (con extensión .class) y la codificación de esos ficheros, por ejemplo:
En este caso, los ficheros .java están en la misma carpeta desde la que se ejecuta javac.exe y le indicamos que la carpeta para los ficheros .class generados sean en la misma carpeta, (en realidad ese comando u opción -d lo podríamos haber obviado) y que el enconding de los ficheros es UTF-8.
Si el código de los ficheros .java está en otra carpeta, por ejemplo, la carpeta src dentro del directorio actual, y queremos que los ficheros .class se guarden en la carpeta actual, podríamos escribir:
Con esto le estamos indicando que utilice el fichero evaluar.jar, que el método main está en la clase Evaluar y por último los parámetros que queremos pasarle al programa.
Otra forma de usar el código compilado (sin necesidad de que el fichero .jar esté presente, aunque sí los ficheros .class) es:
%JAVA_HOME19%\bin\java Evaluar 25+(2*3)+5!
Aquí le indicamos que use el el método main de la clase Evaluar y pase los parámetros indicados como argumentos del programa.
Crear y usar el .jar con un manifiesto que indica dónde encontrar el método main
Pero lo mejor es crear un fichero de manifiesto donde se le indique al comando jar.exe dónde está (o cuál es) el método main que queremos usar.
Para ello creamos un fichero de texto con el siguiente contenido:
Main-Class: Evaluar
Después de Main-Class: indicaremos el nombre de la clase en la que está definido el método main. Recuerda que el nombre de la clase distingue entre mayúsculas y minúsculas.
Esto lo podemos crear directamente desde la línea de comandos escribiendo lo siguiente:
echo Main-Class: Evaluar > manifiesto.txt
Una vez que tenemos ese fichero del manifiesto, podemos crear el fichero .jar de esta forma:
Si esto último lo hacemos con un .jar sin manifiesto obtendríamos el siguiente error:
no main manifest attribute, in evaluar.jar
Nota: El nombre del fichero manifiesto puede ser el que quieras y con la extensión que quieras. Aunque el nombre recomendado es MANIFEST.MF.
De hecho, si abres un fichero .jar (que en realidad es como un fichero comprimido) puedes ver que la estructura en la que se incluye una carpeta llamada META-INF con el manifiesto, incluso si no indicamos un manifiesto esa carpeta y el correspondiente fichero MANIFEST.MF se crea, aunque sin indicar qué clase contiene el método main.
El contenido del MANIFEST.MF, del .jar que hemos generado, sería este si se ha indicado dónde está el método main):
Pues eso… seguimos con los trucos para .NET MAUI, en la primera parte te mostré cómo configurar el proyecto para usar las plataformas que prefieras y cómo configurar el aprovisionamiento para iOS (necesitas una cuenta de Apple Developer). Ahora vamos a ver algunas cosillas referentes al diseño de la aplicación.
Para poder mostrarte estos trucos, he creado una aplicación para .NET MAUI con Visual Studio 2022 (community), pero no la versión Preview, ya que a la hora de escribir esto, la tengo desinstalada y así uso el .NET 6.0 (que es el que por ahora me está dando menos problemas, al menos teniendo el .NET 6 y el .NET 7 RC1). La versión de Visual Studio 2022 es: Microsoft Visual Studio Community 2022 (64-bit) Version 17.3.5
Acabo de instalar la versión 17.3.6 y sigue funcionando bien 😉
Truco 4: Mostrar bien los Frame sin que se corten
Cuando añades un Frame se suelen cortar los bordes (ver la figura 1)
Figura 1. Los frame se cortan las líneas
El código XAML para mostrar esto es el siguiente:
<ScrollView>
<VerticalStackLayout
Padding="10,0"
VerticalOptions="Center">
<Frame>
<VerticalStackLayout Spacing="25">
<Image
Source="dotnet_bot.png"
SemanticProperties.Description="Cute dot net bot waving hi to you!"
HeightRequest="200"
HorizontalOptions="Center" />
<Label
Text="Hello, World!"
SemanticProperties.HeadingLevel="Level1"
FontSize="32"
HorizontalOptions="Center" />
<Label
Text="Welcome to .NET Multi-platform App UI"
SemanticProperties.HeadingLevel="Level2"
SemanticProperties.Description="Welcome to dot net Multi platform App U I"
FontSize="18"
HorizontalOptions="Center" />
<Button
x:Name="CounterBtn"
Text="Click me"
SemanticProperties.Hint="Counts the number of times you click"
Clicked="OnCounterClicked"
HorizontalOptions="Center" />
</VerticalStackLayout>
</Frame>
</VerticalStackLayout>
</ScrollView>
Lo deseable es que esté como en la figura 2.
Figura 2. Los Frame deben mostrar todos los bordes
El truco consiste en añadir un margen al StackLayout que esté contenido en el Frame.
Nota: Este fallo solo ocurre en las aplicaciones de Windows (WinUI)
Tal como te acabo de decir, este fallo (de que se corten las líneas del Frame) solo ocurre en las aplicaciones para Windows (WinUI), al menos en iOS y Android no pasa, tal como puedes ver en las capturas 3 y 4.
Figura 3. La app de prueba en un iPhone 7 plus (iOS)
Figura 4. La app funcionando en un Pixel 4a (Android)
En realidad, al menos en iOS y Android, da igual que esté lo de Margin = «4» como que no, el efecto es prácticamente el mismo.
Truco 5: Cambiar el tamaño de la ventana en Windows
Otro de los problemas (al menos con la compilación actual de .NET MAUI) es que la ventana de la aplicación de Windows (WinUI) se muestra prácticamente a pantalla completa, y, ya te digo que al menos por ahora, ese tamaño no es configurable de forma automática o, que ocurra como en las aplicaciones para Xamarin en la que el usuario es el que decide qué tamaño y posición debe tener la ventana, de forma que en las próximas veces que se abra la aplicación se muestre como se dejó la última vez.
Lo que yo hago en estos casos es usar un tamaño «fijo» (que no es lo suyo, pero…) y asignarlo de esta forma en el constructor de la clase App.
publicApp()
{
InitializeComponent();
// Indicar el tamaño para la app de Windows.
Microsoft.Maui.Handlers.WindowHandler.Mapper.AppendToMapping(nameof(IWindow), (handler, view) =>
{
#if WINDOWS
// Asignar manualmente el tamaño.
int winWidth = 1000;
int winHeight = 900;
var mauiWindow = handler.VirtualView;
var nativeWindow = handler.PlatformView;
nativeWindow.Activate();
IntPtr windowHandle = WinRT.Interop.WindowNative.GetWindowHandle(nativeWindow);
var windowId = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(windowHandle);
var appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(windowId);
appWindow.Resize(new Windows.Graphics.SizeInt32(winWidth, winHeight));
#endif
});
MainPage = newAppShell();
}
Truco 6: Mostrar el título en la barra de la ventana (con colores personalizados)
Otra cosa que estoy haciendo desde hoy (al probar en la aplicación gsCrearTablas_MAUI) es posicionando la ventana y de paso cambiando el color a la barra de título (para que no se vea el color ese tan feo) y también mostrando el título en esa barra de la ventana.
Como puedes ver en la figura 2, no se muestra de color «normal» la barra de título y tampoco tiene un texto.
En la captura 5 puedes ver el color y el texto en la barra de título que podrás conseguir con el código que te muestro a continuación (después de la captura).
Figura 5. La app de Windows con texto y color en la barra de título
La asignación del color y texto de la ventana lo conseguimos haciendo esta asignación (en el código mostrado antes) lo tendrías que poner al final, después de appWindow.Resize.
// El título hay que asignarlo antes de asignar los colores.
appWindow.Title = "Trucos MAUI by elGuille";
// Este es el color que tiene en mi equipo la barra de título.
appWindow.TitleBar.BackgroundColor = Microsoft.UI.ColorHelper.FromArgb(255, 0, 120, 212);
appWindow.TitleBar.ForegroundColor = Microsoft.UI.Colors.White;
Para poder posicionarla, hace falta un truquillo más que es que la ventana se haya mostrado, ya que, si queremos acceder al tamaño de la pantalla, nos dará un valor nulo (o cero).
Nota: El color que asigno a la propiedad BackgroundColor lo he sacado de cómo se muestra el color en mi equipo, por tanto, en tu caso, lo mismo lo tienes que cambiar: FromArgb(255, 0, 120, 212).
Truco 7: Esperar a que la ventana está mostrada para manipular la posición
Esto lo pones también en el primer código que te mostré en el truco 5, después de appWindow.Resize. Fíjate que el cambio del color y el título hay que hacerlo dentro del Dispatcher.Dispatch, si no, el título no se muestra.
// get screen size
DisplayInfo disp = DeviceDisplay.Current.MainDisplayInfo;
double x, y;
// dispatcher is used to give the window time to actually resize
Dispatcher.Dispatch(() =>
{
disp = DeviceDisplay.Current.MainDisplayInfo;
x = (disp.Width / disp.Density - winWidth) / 2;
if (x < 0)
{
x = 0;
}
y = (disp.Height / disp.Density - winHeight) / 2;
if (y < 0)
{
y = 0;
}
appWindow.Move(new Windows.Graphics.PointInt32((int)x, (int)y));
// Si cambiamos la posición, esto hay que hacerlo en el Dispatcher.Dispatch
// El título hay que asignarlo antes de asignar los colores.
appWindow.Title = "Trucos MAUI by elGuille";
// Este es el color que tiene en mi equipo la barra de título.
appWindow.TitleBar.BackgroundColor = Microsoft.UI.ColorHelper.FromArgb(255, 0, 120, 212);
appWindow.TitleBar.ForegroundColor = Microsoft.UI.Colors.White;
Y con esto lo dejo por hoy… voy a seguir investigando (y probando) para poder ponerte algunos trucos más.
El código coloreado usando el condicional de WINDOWS (#if WINDOWS)
Pues eso, que habitualmente se muestra con el color grisáceo ese que te he mostrado antes cuando usas el condicional de compilación para Windows (#if WINDOWS) y, algunas veces, no sé cómo, sale coloreado (que es como debería salir).
Este código es de otra aplicación pero intentaré usar los mismos valores que en este proyecto de pruebas.
// Indicar el tamaño para la app de Windows.
Microsoft.Maui.Handlers.WindowHandler.Mapper.AppendToMapping(nameof(IWindow), (handler, view) =>
{
#if WINDOWS
// Asignar manualmente el tamaño. int winWidth = 800; // 1700; // 2800;int winHeight = 640; //1800var mauiWindow = handler.VirtualView;
var nativeWindow = handler.PlatformView;
nativeWindow.Activate();
IntPtr windowHandle = WinRT.Interop.WindowNative.GetWindowHandle(nativeWindow);
var windowId = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(windowHandle);
var appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(windowId);
//appWindow.Resize(new Windows.Graphics.SizeInt32(winWidth, winHeight));// get screen sizeDisplayInfo disp = DeviceDisplay.Current.MainDisplayInfo;
double x, y;
// dispatcher is used to give the window time to actually resize
Dispatcher.Dispatch(() =>
{
disp = DeviceDisplay.Current.MainDisplayInfo;
// Si Density es diferente de 1, ajustar el tamaño.if (disp.Density > 1)
{
winWidth = (int)(winWidth * disp.Density);
winHeight = (int)(winHeight * disp.Density);
}
// El tamaño de la pantalla de este equipo.int screenW = (int)(disp.Width / disp.Density);
int screenH = (int)(disp.Height / disp.Density);
// Si el alto indicado es mayor, ponerlo para que entre en esta pantalla.if (winHeight > screenH)
{
winHeight = screenH - 60;
}
// Si el ancho indicado es mayor, ponerlo para que entre en esta pantalla.if (winWidth > screenW)
{
winWidth = screenW - 60;
}
appWindow.Resize(new Windows.Graphics.SizeInt32(winWidth, winHeight));
x = (screenW - winWidth) / 2;
if (x < 0)
{
x = 0;
}
y = (screenH - winHeight - 40) / 2;
if (y < 0)
{
y = 0;
}
appWindow.Move(new Windows.Graphics.PointInt32((int)x, (int)y));
// El título hay que asignarlo antes de asignar los colores.
appWindow.Title = "Trucos MAUI by elGuille";
// Este es el color que tiene en mi equipo la barra de título.
appWindow.TitleBar.BackgroundColor = Microsoft.UI.ColorHelper.FromArgb(255, 0, 120, 212);
appWindow.TitleBar.ForegroundColor = Microsoft.UI.Colors.White;
});
#endif
});
Y, ya sabes, si te parece bien, puedes hacer un donativo con PayPal, que es como si me invitaras a un refresco, es decir, no es necesario que me dejes toda tu herencia, solo un par de euritos de nada… 😉
Nos vemos. Guillermo
P.S. El repositorio de GitHub ya está creado: Trucos_MAUI.
P.S.2 Por cierto, ahora no me funciona la app para iOS. El error que da es:
Error CS1705: Assembly ‘Microsoft.Maui’ with identity ‘Microsoft.Maui, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null’ uses ‘Microsoft.iOS, Version=16.0.0.0, Culture=neutral, PublicKeyToken=84e04ff9cfb79065’ which has a higher version than referenced assembly ‘Microsoft.iOS’ with identity ‘Microsoft.iOS, Version=15.4.300.0, Culture=neutral, PublicKeyToken=84e04ff9cfb79065’
He buscado (con BING, ya que con Google no encontraba nada al poner esa cadena) para ver de qué va esto y lo que he encontrado (https://github.com/dotnet/maui/issues/8858) dice que ya está resuelto (o algo así) y en teoría la solución que da a mí no me funciona, que si no he entendido mal es dotnet workload install (supongo que indicando o maui o ios) pero nada, también he probado con dotnet workload install ios, con dotnet workload update, con dotnet workload repair y posicionándome en el directorio del proyecto con dotnet workload restore Trucos_MAUI.csproj, pero nada de nada… Ni siquiera usando el peasso de comando este: dotnet workload install maui --from-rollback-file https://aka.ms/dotnet/maui/6.0.408.json --source https://aka.ms/dotnet6/nuget/index.json --source https://api.nuget.org/v3/index.json Pero nada de nada… ya, por último, hasta he desinstalado el Visual Studio (en realidad he usado la opción Rollback to previous version) la versión 17.3.6 (a la 17.3.5) pero tampoco ha solucionado nada de nada, así que… he vuelto a instalar la versión 17.3.6, que es la última a día de hoy. A ver si para la siguiente tanda de trucos tengo la solución. 🤞🏻🙏🏻
P.S.3 (12-oct-22 17.35) He creado otra entrada (Errores de iOS con .NET MAUI) con el problema este que te comento en el «P.S.2» con idea de ver si lo soluciono.
Pues eso… aquí te muestro algunos trucos para usar con .NET MAUI para que no pierdas la razón como me está pasando a mí 😉
Para poder mostrarte estos trucos, he creado una aplicación para .NET MAUI con Visual Studio 2022 (community), pero no la versión Preview, ya que a la hora de escribir esto, la tengo desinstalada y así uso el .NET 6.0 (que es el que por ahora me está dando menos problemas, al menos teniendo el .NET 6 y el .NET 7 RC1). La versión de Visual Studio 2022 es: Microsoft Visual Studio Community 2022 (64-bit) Version 17.3.5
Acabo de instalar la versión 17.3.6 y sigue funcionando bien 😉
Truco 1: Crear la aplicación de pruebas y hacer que funcione
Lo primero es quitar las advertencias en los paquetes de NuGet (ver figura 1).
Figura 1. Advertencias en las dependencias del proyecto
Esto se soluciona ejecutando la aplicación (en mi caso para Windows).
Truco 2: Quitar los tipos de aplicaciones que no quieras usar
Aunque de paso he quitado el soporte para maccatalyst (ya que no tengo un Mac para poder probarlo). Esto es fácil de hacer, abres el fichero del proyecto (botón secundario sobre el nombre del proyecto, en mi caso Trucos_MAUI) y selecciona Edit Project File (en español será con otro texto: Editar el archivo de proyecto o algo así).
En la parte superior, busca esta línea: <net6.0-android;net6.0-ios;net6.0-maccatalyst> y cámbiala por esta otra: <net6.0-android;net6.0-ios>.
Truco 3: Usar la aplicación para iOS (iPhone, etc.)
Para poder usar la aplicación en iOS debes tener una cuenta en Apple Developer (99€ al año) y configurarlo para que use la versión «individual», es decir, con la definición normal de la cuenta no me funciona, y hay que asignar los valores de forma manual (yo ya los tengo asignados, pero voy a ver si te explico cómo hacerlo).
En las propiedades del proyecto (botón secundario en el proyecto y Properties del menú desplegable), selecciona en la parte de la izquierda iOS > Bundle Signing y en Scheme selecciona Automatic Provisioning (ver figura 2)
Figura 2. Configurar Bundle Signing para iOS
Pulsa en el «enlace» Configure Automatic Provisioning y te mostrará un asistente en el que tendrás que indicar la cuenta de Apple (puede ser que la tengas que indicar antes) y de ahí seleccionar la que hayas definido como cuenta de individual (no la que tiene el ID de Apple, si no la que configures manualmente, (ahora te explico cómo) (ver figura 3)
Figura 3. Las cuentas para configurar el aprovisionamiento para iOS
Para configurar la cuenta, pulsa en el enlace Manage Account (figura 2) y ahí tendrás que añadir tu ID de Apple (normalmente una cuenta de correo electrónico).
En el botón «Add» selecciona «Indivudual Account» (figura 4) y rellena los datos que te pide (en Apple Developer puedes encontrar esos datos y cómo crear el «private key». (figura 5).
Figura 4. añadir una cuenta individual
Figura 5. Configurar la cuenta individual
Nota: Si necesitas saber cómo configurar la cuenta individual (figura 5), puedo ayudarte por un módico precio, vamos como una invitación virtual, pero me lo tienen que pedir y ya nos arreglamos con el donativo por PayPal 😉
Una vez que tienes todo esto, ya solo es compilar y cantar… 😉
Después sigo explicándote más cosas (pero lo primero era crear el proyecto de pruebas).
Este proyecto lo publicaré ya está publicado en GitHub para que puedas descargarlo e ir viendo el código y el diseño (ver abajo el enlace).
Nos vemos. Guillermo
P.S. El repositorio de GitHub ya está creado: Trucos_MAUI.
Pues eso, que al crear un proyecto para .NET MAUI con Visual Studio 2022 (no preview), concretamente con Microsoft Visual Studio Community 2022 (64-bit) – Version 17.3.5, al intentar usar el proyecto (incluso sin modificar nada) me soltaba ese error: Platform version is not present for one or more target frameworks (concretamente para ios).
Buscando en la red de redes (internet) me topé con varias soluciones que no solucionaban nada (o yo no sabía cómo aplicar esas soluciones, todo hay que decirlo), y al final «trasteando» con el comando workload de dotnet (que en su día usé, sin éxito, para intentar instalar el workload de iOS), probé con una de las opciones o comandos que te da. Al usar dotnet workload -h te muestra esto:
Commands:
install <WORKLOAD_ID> Install one or more workloads.
update Update all installed workloads.
list List workloads available.
search <SEARCH_STRING> Search for available workloads.
uninstall <WORKLOAD_ID> Uninstall one or more workloads.
repair Repair workload installations.
restore <PROJECT | SOLUTION> Restore workloads required for a project.
Y de ahí la que he usado es la última, que suena bien…
Así que, te sitúas en el directorio en el que está el proyecto de .NET MAUI, y escribes (todo esto en la terminal, el shell o línea de comandos, como prefieras llamarlo):
dotnet workload restore "nombre del proyecto.csproj"
Por supuesto, debes sustituir «nombre del proyecto.csproj» por el nombre de tu proyecto y no es necesario ponerlo entre comillas.
Nota: Puede ser que a los workloads se le vaya la olla… sí… así que… lo mismo un dotnet workload repair puede que lo tengas que usar.
Pues eso… ahora le toca lo de cambiar el tamaño de una ventana de Windows (WinUI que es como se llama la plataforma de Windows en .NET MAUI (en Xamarin es UWP), aquí solo te voy a mostrar el código de un tamaño fijo, ya que no me he puesto a experimentar cómo usar el tamaño predeterminado, ya que la forma de hacerlo es con otras APIs y… pues eso… que no me gusta demasiado el .NET MAUI como para dedicarle más tiempo de lo justo y necesario… 😉
Lo que si te quiero decir, es que precisamente me puse a mirar todo esto de cambiar el tamaño porque a diferencia de las aplicaciones con Xamarin.Forms, als de .NET MAUI «no recuerdan» el tamaño de la ventana en las siguientes veces que se use la aplicación, algo que en las de Xamarin sí hace, es decir, se muestra con el tamaño predeterminado y si cambias el tamaño de la ventana, la próxima vez que se utilice usará ese último tamaño.
Pero en las aplicaciones de .NET MAUI, siempre usa el tamaño «grande» y… pues como que no, por eso me puse a investigar, primero para hacerlo en .NET MAUI, y ya puestos me puse a mirar para Xamarin.
¿Cómo cambiar el tamaño de la ventana de Windows (WinUI) en un proyecto de .NET MAUI?
Es muy simple, el código se pone en el constructor de la clase App principal (no la del proyecto de Windows) y el código podría ser como este que te muestro para poner la ventana en un tamaño de 800 x 900 (ancho x alto).
namespace CambiarTamañoWindows_MAUI;
publicpartialclassApp : Application
{
publicApp()
{
InitializeComponent();
// Indicar el tamaño para la app de Windows.
Microsoft.Maui.Handlers.WindowHandler.Mapper.AppendToMapping(nameof(IWindow), (handler, view) =>
{
#if WINDOWS
// Asignar manualmente el tamaño.
int winWidth = 800;
int winHeight = 900;
var mauiWindow = handler.VirtualView;
var nativeWindow = handler.PlatformView;
nativeWindow.Activate();
IntPtr windowHandle = WinRT.Interop.WindowNative.GetWindowHandle(nativeWindow);
var windowId = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(windowHandle);
var appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(windowId);
appWindow.Resize(new Windows.Graphics.SizeInt32(winWidth, winHeight));
#endif
});
MainPage = newAppShell();
}
}
Y esto es todo lo que hay que hacer… simple, ¿verdad? pues sí, para qué engañarnos, aunque eso de tener que ponerlo en un condicional de compilación es un rollo, pero tiene sentido ya que solo es para un proyecto de Windows. El problema es que no te muestra nada el «intellisense» ni nada de esas monerías que tenía en el proyecto para Xamarin.
Una captura con el programa en funcionamiento.
Figura 1. La aplicación en funcionamiento.
Y esto es todo… ahora subiré el código (o parte de él) a GitHub y después te pondré el enlace.
Acuérdate de (si quieres) hacer un donativo en PayPal para poder seguir teniendo este sitio en funcionamiento, gracias.
Pues eso… ¡A la pila tiempo! A ver si me acuerdo de cómo se escriben los posts en el blog… que ya hace tiempo que no publico nada. Y en esta ocasión es para contarte cómo cambiar el tamaño de una aplicación de Windows (UWP) creada con Xamarin.Forms.
No me voy a enrollar demasiado porque quiero ponerte otro ejemplo para .NET MAUI, ya que, según he visto por la red (y lo que yo he probado) es que se hace de forma diferente.
Básicamente hay dos formas de hacerlo, una es dejando que sea el propio Windows el que se encargue del tamaño (y de recordar el último tamaño que el usuario ha puesto o, mejor dicho, el último tamaño asignado por el usuario (cambiando el tamaño de la ventana).
Para hacer esto en Xamarin.Forms, tenemos que hacerlo en el proyecto para UWP. Normalmente te dicen que en el método OnLaunched de la clase App (la del proyecto para UWP, no la del proyecto principal con la funcionalidad).
Pero en las pruebas que últimamente he hecho, también se puede hacer en el constructor de MainPage (la página principal del proyecto para UWP).
¿Por qué hacerlo en un sitio o en otro?
Si no vas a hacer nada especial, puedes ponerlo en el método OnLaunched (ahora te explico en qué parte de ese método).
Si quieres hacer algo, por ejemplo, usar valores que has asignado en la clase App del proyecto Xamarin, lo mejor es hacerlo en el constructor de MainPage, porque en ese constructor se instancia el objeto App del proyecto principal (en el que se define la funcionalidad de la aplicación y que está referenciado en el proyecto UWP o en los de Android, iOS, etc.). Y al hacerlo después de la llamada a LoadApplication(new EspacioDeNombres.App()); nos aseguramos que ese objeto esté instanciado y así poder acceder a los valores que tengas asignados, que pueden ser leídos de un fichero de configuración, una base de datos, asignados directamente, etc.
Un ejemplito, por favor
Vamos a suponer que quieres que tu aplicación (cuando se use en Windows) tenga, por ejemplo, un tamaño de 450×650 (ancho x alto). Creo que el ancho mínimo es 400, pero solo es una conjetura.
Este sería el código a utilizar en OnLaunched.
Aclararte que deberías poner una importación del espacio de nombres Windows.UI.ViewManagement para poder acceder a la clase ApplicationView y a la enumeración ApplicationViewWindowingMode. Por otro lado, el tamaño se asigna con un objeto Size que está definido en Windows.Foundation, por tanto, asegúrate que tengas esas dos importaciones.
using Windows.Foundation;
using Windows.UI.ViewManagement;
Repetimos: El siguiente código que te muestro es el método OnLaunched de la clase App del proyecto para UWP, solo he quitado la parte de #if DEBUG ya que, no nos interesa y así seguro que sabes exactamente dónde poner el código para cambiar o asignar el tamaño de la ventana de Windows (UWP).
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used such as when the application is launched to open a specific file.
///</summary>
///<paramname="e">Details about the launch request and process.</param>
protectedoverridevoid OnLaunched(LaunchActivatedEventArgs e)
{
Frame rootFrame = Window.Current.Content asFrame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = newFrame();
rootFrame.NavigationFailed += OnNavigationFailed;
Xamarin.Forms.Forms.Init(e);
if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: Load state from previously suspended application
}
// Asignar manualmente el tamaño. (04/sep/22 17.50)
int winWidth = 450; // el mínimo creo que es 400 de ancho
int winHeight = 650;
//Xamarin.Forms.Forms.Init(e, assembliesToInclude);
ApplicationView.PreferredLaunchViewSize = newSize(winWidth, winHeight);
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.PreferredLaunchViewSize;
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
// Ensure the current window is active
Window.Current.Activate();
}
Y esto es todo… al menos para que la aplicación se cargue con ese tamaño… aunque debes tener en cuenta una cosita que explican esta gente de Microsoft en la documentación de la propiedad ApplicationView.PreferredLaunchViewSize y es lo que te pongo en el siguiente «quote» (en inglés y la traducción):
This property only has an effect when the app is launched on a desktop device that is not in Tablet mode (Windows 10 only).
For the very first launch of an app the PreferredLaunchWindowingMode will always be Auto and the ApplicationView.PreferredLaunchViewSize will be determined by system policies. The API applies to the next launch of the app.
— … —
Esta propiedad solo tiene efecto cuando la aplicación se inicia en un dispositivo de escritorio que no está en modo tableta (solo Windows 10).
Para el primer lanzamiento de una aplicación, PreferredLaunchWindowingMode siempre será Auto y ApplicationView.PreferredLaunchViewSize estará determinado por las políticas del sistema. La API se aplica al próximo lanzamiento de la aplicación.
Es decir, que solo vale para UWP en escritorio (Desktop) y que la primera vez que se ejecute la aplicación usará el tamaño predeterminado, pero en las siguientes usará el tamaño que se asigne.
¿Queda claro?
Pues si no te ha quedado claro, prueba y lo comprenderás mejor 😉
Seguimos.
Si lo quieres hacer en el constructor de MainPage, este sería el código. En este ejemplo, se supone que la App (la de Xamarin, el proyecto con la funcionalidad) define un par de valores para el ancho y el alto y esos serán los valores que se asignarán a la aplicación (pero recuerda lo que se indica en la nota anterior, que la primera vez no tendrá efecto, si no, en las siguientes).
Veamos el código de ejemplo, con la definición de esas dos «propiedades» accedidas desde el proyecto de UWP.
Este sería el código de la clase App del proyecto principal de Xamarin.
Si te fijas en el código, he usado la definición del espacio de nombres al estilo de C# 10.0 (File-scoped namespace declaration) para poder hacer eso sin que te de error, debes indicar que usas la última versión de C#, esto lo haces en el proyecto poniendo lo de: <LangVersion>latest</LangVersion>.
namespace CambiarTamañoWindows.UWP
{
publicsealedpartialclassMainPage
{
publicMainPage()
{
this.InitializeComponent();
LoadApplication(new CambiarTamañoWindows.App());
// Asignar manualmente el tamaño según esté definido en la App del proyecto con la funcionalidad.double winWidth = CambiarTamañoWindows.App.WindowsWidth;
double winHeight = CambiarTamañoWindows.App.WindowsHeight;
ApplicationView.PreferredLaunchViewSize = newSize(winWidth, winHeight);
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.PreferredLaunchViewSize;
}
}
}
En este caso no he usado lo del «namespace file-scoped» en el proyecto de UWP porque es algo más lioso indicar la versión del C#. Pero… vale, te lo explico, pero antes te explico ese código.
El poner el cambio de la ventana después de LoadApplication es porque el parámetro que se le pasa es una llamada al constructor de la clase (es decir, se instancia esa clase) y si al instanciarla lees los valores de una base de datos, un fichero de configuración o lo que sea, debes usarlos solo después de haberlos asignados.
En este ejemplo los dos valores usados son «static», es decir, que no pertenecen a una instancia en particular, sino a toda la clase y a todas las instancias.
Si no te gusta trabajar con valores compartidos, puedes asignar esa instancia a una variable, usar esa variable en el método LoadApplication y después usar los valores desde ese objeto.
Para que no imagines nada, supón que la definición de esas dos propiedades está hecha de esta forma:
El código del constructor de MainPage sería este otreo:
namespace CambiarTamañoWindows.UWP
{
publicsealedpartialclassMainPage
{
publicMainPage()
{
this.InitializeComponent();
// Instanciamos la clase para que pueda asignar los valores.var laApp = new CambiarTamañoWindows.App();
LoadApplication(laApp);
// Asignar manualmente el tamaño según esté definido en la App del proyecto con la funcionalidad.double winWidth = laApp.WindowsWidth;
double winHeight = laApp.WindowsHeight;
ApplicationView.PreferredLaunchViewSize = newSize(winWidth, winHeight);
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.PreferredLaunchViewSize;
}
}
}
Después publicaré en github el proyecto para que te resulte más fácil probarlo y verlo al completo.
Cambiar la versión de C# en un proyecto Xamarin para Android, UWP (e incluso iOS, etc.)
Antes se podía hacer desde las propiedades del proyecto, en Build y seleccionando Avanzada, pero ya no, ya que dice que se selecciona automáticamente según la versión del «frameword», tal como puedes ver en esta captura:
Figura 1. Desde aquí ya no se puede indicar la versión de C#
La forma de hacerlo (estoy hablando de los proyectos de Android o de UWP, etc.) es la siguiente:
1- Elige el proyecto en el explorador de soluciones y pulsa en descargar (figura 2) 2- Una vez descargado, en ese mismo proyecto, selecciona Editar el archivo del proyecto (figura 3) 3- Añade <LangVersion>latest</LangVersion> después de la definición de PropertyGroup y lo guardas (figura 4). 4- Vuelve a cargar el proyecto (como en la figura 2, pero en vez de Unload será Reload). 5- Esto mismo lo puedes hacer en el de Android, etc.
Figura 2. Descargar el proyecto.Figura 3. Editar el proyecto.Figura 4. La versión a usar.
Y con esto y un bizcocho… ya casi son las 8…
En la figura 5 tienes la app funcionando con un tamaño de ventana de 650 x 700.
Figura 5. La app funcionando con un tamaño de 650×700
Ahora sí, esto es todo amigos… recuerda «invitarme» a un refresco virtual haciendo un donativo con Paypal 😉
Pues eso… ahora esto de los ficheros con la extensión .json es lo que está en la «onda» y… pues habrá que aprovecharlo que incluso es fácil usarlo en las aplicaciones de .NET.
Espero que no sirva de precedente, pero en este post no hay ejemplo para Visual Basic, solo para C#. No es porque yo abandone mis END IFs y me pase definitivamente a las llaves y puntos y comas, es porque acabo de terminar una clase «serializable» y la he escrito en C# y por vagancia, no he querido crear un ejemplo en Visual Basic. Eso sí, esta clase la utilizo desde código de Visual Basic, ya que en C# solo he hecho la clase, y como he comprobado que los ejemplos que he consultado no hacían bien el trabajo, me he decidido a escribir esta entra en el blog (post).
La clase que serializo es muy simple, es para «recordar» los tamaños de las columnas de, en mi caso, un DataGridView. Esa cuadrícula utiliza distintos tipos de nombres y anchos de columnas, por tanto, el objeto que contiene los valores está formado por un diccionario en el que la clave es una cadena (string), para saber el tipo de datos mostrados, y los valores es otro diccionario de tipo entero en la clave y el valor que guardará serán el índice de la columna y el ancho de la misma.
Esa propiedad está definida de la siguiente forma:
///<summary>
/// Diccionario para el tipo de listado y los valores de cada columna
/// (por índice) y el ancho de la columna.
///</summary>
[JsonPropertyName("anchos")]
publicDictionary<string, Dictionary<int, int>> Anchos { get; set; } = new();
El atributo JsonPropertyName es el que le indica al compilador que esa propiedad es serializable y que está enlazada con el valor anchos del fichero .json.
Esta es la parte fácil.
Ahora hay que leer y guardar los datos en el fichero de texto con la extensión que queramos, pero que en este ejemplo utilizo el valor estándar: .json.
Y estos son los métodos principales para guardar (Save) y leer (Load) el contenido de la clase en el fichero. Save guarda el contenido de la clase en el fichero (lo serializa) y Load lee el contenido del fichero (lo de-serializa) y lo asigna a un objeto del tipo de la clase del tipo donde está definida esa propiedad. No te líes. Es más sencillo el código que explicar lo que hace… 😉
///<summary>
/// Carga los valores del fichero indicado.
///</summary>
///<paramname="fileName">El path del fichero a leer y devolver el contenido.</param>
///<returns>El objeto leído del fichero indicado.</returns>
privatestaticAnchoColumnas Load(string fileName)
{
// Abrir el fichero para leer, compartido para lectura y escritura.
usingvar stream = newFileStream(fileName,
FileMode.OpenOrCreate,
FileAccess.Read,
FileShare.ReadWrite);
// Si tiene contenido, deserializarlo, si no, devolver un valor nulo.
if (stream.Length > 0)
returnJsonSerializer.Deserialize<AnchoColumnas>(stream);
else
returnnull;
}
///<summary>
/// Guarda los datos de tipo AnchoColumnas indicado.
///</summary>
///<paramname="anchosColumnas"></param>
///<paramname="fileName"></param>
///<returns></returns>
privatestaticvoid Save(AnchoColumnas anchosColumnas, string fileName)
{
// Abrir el fichero para escribir, compartido para lectura y escritura.
usingvar stream = newFileStream(fileName,
FileMode.OpenOrCreate,
FileAccess.Write,
FileShare.ReadWrite);
// Que se indente el contenido.
var options = newJsonSerializerOptions { WriteIndented = true };
// Guardar (serializar) el contenido de la clase.
JsonSerializer.Serialize<AnchoColumnas>(stream, anchosColumnas, options);
}
En mi caso, he creado otros dos métodos llamados Guardar y Leer en el que asigno el nombre del fichero que contendrá los datos serializados de la clase. Ese fichero está en el path del ejecutable.
Este es el código:
///<summary>
/// Guardar los datos de los anchos de los listados.
///</summary>
///<paramname="anchosColumnas"></param>
publicstaticvoid Guardar(AnchoColumnas anchosColumnas)
{
// El fichero está en la carpeta del ejecutable.
var fic = Path.Combine(Application.StartupPath, "AnchosColumnas.json");
Save(anchosColumnas, fic);
}
///<summary>
/// Leer los anchos de las columnas.
///</summary>
///<returns></returns>
publicstaticAnchoColumnas Leer()
{
// El fichero está en la carpeta del ejecutable.
var fic = Path.Combine(Application.StartupPath, "AnchosColumnas.json");
return Load(fic);
}
Como puedes comprobar, el método Guardar recibe como parámetro la clase a serializar y el método Leer devuelve un objeto con la clase deserializada (o un valor nulo en caso de que aún no tenga contenido el fichero).
La parte interesante está en los métodos Save y Load, ya que utilizo código «seguro» a la hora de leer o escribir en un fichero que no exista. Y el truco está en crear el objeto de tipo Stream usando FileStream en lugar de usar los métodos OpenRead u OpenWrite de la clase File, ya que, para usar esos dos métodos habría que hacer comprobaciones si existen, si están compartidos, etc., etc., etc.
Por último, en esa misma clase tengo un método (también compartido o estático) para acceder a la información. Es una propiedad de solo lectura, que se encarga de asignar/leer el objeto si debe hacerlo (cuando inicialmente no está asignado).
Este es el código:
privatestaticAnchoColumnas _AnchosColumnas = null;
///<summary>
/// Los anchos de las columnas de los listados.
///</summary>
publicstaticAnchoColumnas AnchosColumnas
{
get
{
if (_AnchosColumnas == null)
{
_AnchosColumnas = Leer();
if (_AnchosColumnas == null)
{
_AnchosColumnas = new();
}
}
return _AnchosColumnas;
}
Y finalmente te muestro cómo uso esa clase desde el código que tengo en Visual Basic:
Primero para asignar las columnas al objeto DataGridView (en el código indicado por lvDatos) y después cuándo guardar los nuevos valores, cosa que hago en el evento ColumnWidthChanged.
La asignación de los anchos guardados lo hago en un método (con más código del mostrado) en el que asigno los valores de las columnas, tanto el texto a mostrar como el ancho, y por supuesto el número de las mismas.
Este es el código para leer los valores guardados y asignarlos a las columnas del objeto lvDatos:
' Asignar los anchos que estén guardados. (22/abr/22 20.34)
IfAnchoColumnas.AnchosColumnas.Anchos.ContainsKey(value.ToString()) = FalseThen
AnchoColumnas.AnchosColumnas.Anchos.Add(value.ToString(),
NewDictionary(OfInteger, Integer))
EndIf
Dim cols = AnchoColumnas.AnchosColumnas.Anchos(value.ToString())
If cols.Keys.Count = 0 Then
For i = 0 To lvDatos.Columns.Count - 1
cols.Add(i, lvDatos.Columns(i).Width)
Next
Else
For i = 0 To cols.Keys.Count - 1
lvDatos.Columns(i).Width = cols(i)
Next
d EndIf
El valor de la variable «value» es el nombre de la enumeración que utilizo y que es un valor asignado como parámetro de este método (recuerda que esto es solo un extracto en el que se asignan los valores leídos, si es que existe el fichero con esos valores ya guardados).
Y para finalizar, el código del evento ColumnWidthChanged, en el que, tengo puesto una comprobación de si se está inicializando (cuando se carga el formulario) con idea de que no se guarden los valores iniciales que tenga.
PrivateSub lvDatos_ColumnWidthChanged(sender AsObject, e AsDataGridViewColumnEventArgs) Handles lvDatos.ColumnWidthChanged
' Cambiar el ancho de las columnas de los totales (10/mar/22 04.28)
' al cambiar el del principal.
If inicializando ThenReturn
' Asignar y guardar los valores. (22/abr/22 20.39)
Dim value = TipoListado.ToString()
With lvDatos
IfAnchoColumnas.AnchosColumnas.Anchos.ContainsKey(value) = FalseThen
AnchoColumnas.AnchosColumnas.Anchos.Add(value, NewDictionary(OfInteger, Integer))
EndIf
' Asegurarse que se asignan correctamente.
Dim cols = AnchoColumnas.AnchosColumnas.Anchos(value)
cols.Clear()
For i = 0 To .Columns.Count - 1
cols.Add(i, .Columns(i).Width)
Next
AnchoColumnas.Guardar(AnchoColumnas.AnchosColumnas)
EndWith
EndSub
Y esto es todo… otro día pondré el código para Visual Basic de la clase y un ejemplo de cómo usarla escrito en C#, pero eso será en otra ocasión 😉
Pues eso… que estoy usando algunas máquinas virtuales de Hyper-V para los canales de Windows Insider, una de ellas con la del canal Dev (más inestable) y otra con el canal Beta (algo más estable) y cada vez que enciendo el equipo (o lo reinicio tras una actualización) tengo que abrir el Hyper-V Manager para poder acceder a esas máquinas virtuales.
Pensando (algunas veces me da por pensar estas cosas) que lo más simple sería poder tener un acceso directo y abrir las máquinas sin tener que usar el administrador de Hyper-V, así que… buscando en la red me encontré que es fácil hacerlo… pero como suelo darle nombres (con espacios) a esas máquinas virtuales, en esos ejemplos no aclaraban cómo hacerlo, así que… me he decido a publicar esto para que quede constancia de cómo hacerlo (ya sabes, después de un tiempo puede que se me olvide y así podré encontrarlo al hacer una búsqueda en la red de redes 😉 )
Y de paso, te lo explico por si quieres hacerlo.
Primero lo primero
Lo primero a tener en cuenta es cómo crear ese acceso directo.
Para crear un acceso directo lo puedes hacer de dos formas.
La primera: Te posicionas en el directorio donde quieres crear ese acceso directo, por ejemplo, en el escritorio (que es la opción más rápida si quieres evitar tener que abrir esa carpeta con el acceso directo), pulsas en el botón secundario y de las opciones mostradas (ver captura 1 que es de Windows 11, pero en las versiones anteriores de Windows será algo parecido, pero con otro look) es elegir Nuevo > Acceso directo (New > Shortcut).
Captura 1. Crear un acceso directo en Windows 11.
A continuación, escribe el path del administrador de Hyper-V, que es el siguiente: C:\Windows\System32\vmconnect.exe (ver captura 2).
Captura 2. Indicar el path de vmconnect.exe
Tip: No lo busques en la carpeta de Archivo de Programas > Hyper-V, que ahí no está, ya que suele estar en C:\Windows\System32.
Pulsa en Siguiente (Next) y si quieres le cambias el nombre del nuevo acceso directo y finalmente pulsas en Finalizar (Fisnish) (ver captura 3).
Captura 3. Indicar el nombre del acceso directo
La segunda: Abre la ubicación de vmconnect.exe (que tal como te he indicado antes está en C:\Windows \System32, si en lugar de C usas otro nombre de unidad como arranque, indica ese nombre de unidad).
Busca el fichero vmconnect.exe y pulsa sobre la aplicación con en el botón secundario (el derecho para diestros, el izquierdo para zurdos) y selecciona crear acceso directo (como no podrás crearlo en la ubicación del programa, te preguntará si quieres crearlo en el escritorio).
El acceso directo estará en el escritorio.
Una vez creado el acceso directo a vmconnect.exe
Selecciona el acceso directo y pulsa con el botón secundario para elegir propiedades.
Después de la ubicación de vmconnect.exe indica el nombre del servidor de Hyper-V seguido del nombre de la máquina virtual.
En mi caso, sería GUILLE-JUL1421 «Windows 11Pro Dev» (ver captura 4).
Fíjate en las comillas dobles para el nombre de la máquina virtual, esto es así porque contiene espacios. Si el nombre de la máquina virtual no tiene espacios no es necesario ponerlo dentro de comillas dobles.
Captura 4. Usar comillas dobles si alguno de los parámetros tienen espacios
Dale permisos de administrador al acceso directo
Es necesario que le des acceso de administrador al acceso directo.
Para ello, en las propiedades del acceso directo, pulsa en el botón Avanzado (Advanced) y marca la casilla de Ejecutar como administrador (Run as administrator) (ver la captura 5), y acepta hasta cerrar la ventana de propiedades.
Captura 5. Indicar que el acceso directo se ejecute como administrador
Para saber con seguridad cómo se llama el servidor de Hyper-V y la máquina virtual, puedes verlo abriendo el administrador de Hyper-V (Hyper-V Manager) y así estar seguro (ver captura 6).
Captura 5. El administrador de Hyper-V
Nota: En algunas ocasiones, al abrir los 2 accesos directos que suelo utilizar, en Windows 11, me los muestra en la barra de tareas como 2 iconos (ver captura 7) y otras veces como un solo icono, mostrando las dos opciones al pasar el ratón sobre él (ver captura 8). En las versiones anteriores de Windows te los mostrará según tengas configurada la barra de tareas para mostrar los iconos relacionados con una misma aplicación.
Si abres las 2 máquinas virtuales desde el administrador de Hyper-V siempre te los mostrará como un solo icono.
Captura 7. En Windows 11 algunas veces (usando los accesos directos) los muestra como 2 iconos separados
Captura 8. La forma habitual de mostrar los iconos de un mismo tipo de aplicación en Windows 11
Y esto es todo… espero que te sea de utilidad… y si así ha sido (o no), no te olvides de invitarme a un «refresco virtual» 😉 (pulsando en el botón donar de PayPal). Gracias.
Pues eso… que quería usa el Dev Channel de Windows Insider para tener la versión más reciente (aunque posiblemente más inestable) de Windows 11 y no me dejaba, solo me permitía los canales Beta y Release Preview. Y mire en la configuración de Hyper-V y… ¡ahí estaba la solución!
Y no es más que activar las opciones de Enable Trusted Platform Module (TPM) en la «pestaña» Security (ver la figura 1).
Figura 1. Configuración de una máquina virtual de Hyper-V para habilitar TPM.
No sé si será Es necesario marcar también la opción Encrypt state and virtual machine migration traffic, pero «for if las flais» también la he marcado (seleccionado), además de indicarle que utilice 2 procesadores virtuales (en la «pestaña» Processor).
Y con esos cambios ya me deja seleccionar (y que funcione) el canal «DEV» de Windows Insider Program.
Nota del 13-dic-21 01:57: De todo lo dicho, además agrego que, con las pruebas hechas, si ponía 5120MB de RAM (5GB) no me lo daba por bueno… Con 6000MB (6GB) si lo da por bueno, ver la figura 2. Y eso que dice que «al menos tiene 4GB de RAM», en fin…)
Figura 2. Con 6000MB (6GB) si lo da por bueno, con 5GB no me lo da por «compatible» para Windows 11.
Espero que te sea de utilidad… ¡esa es siempre la intención! 😉
