Archivo de la etiqueta: C#Sharp

Temas relacionados con C#

Usar una class library desde proyecto de .NET MAUI

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.

Nos vemos.
Guillermo

Ejemplos de Google Cloud Natural Language para consola y .NET MAUI

Pues eso… aquí te dejo el código de una clase (Frases) para analizar un texto usando la API de Google Cloud Natural Language y un par de proyectos para usar esa clase. Los proyectos son para una aplicación de consola y para dispositivos usando .NET MAUI. Todo el código está para C#.

No te voy a explicar mucho por aquí, salvo lo indicado en el siguiente párrafo, pero te dejo todo el código fuente (para C#) en este repositorio de GitHub.
También incluyo algunas explicaciones y problemas que he tenido para usar la clase en el proyecto para .NET MAUI (no muchos, pero…)

Algunos trucos en el código de .NET MAUI

Un par de cosas que siempre suelo poner en los proyectos para .NET MAUI, porque no tienen la misma funcionalidad que con Xamarin.Forms, son:

  1. Definir el tamaño de la ventana para Windows, ya que en .NET MAUI la ventana se muestra enorme y no recuerda el tamaño último.
    Esto lo hago en el constructor de la clase App.
  2. Hacer que el control Frame se vea al completo (no se corte por la parte inferior).
    Esto lo consigo si en el StackLayout usado después del Frame se le deja un margin mínimo de 2.

Además, he añadido el código para simular un Expander ver figura 1).
Este expander lo utilizo para mostrar u ocultar la lista de textos de prueba.

Otra cosa interesante es usar un objeto Task (usar otro proceso) cuando se pulsa en el botón de analizar, con idea que se muestre el texto mientras está analizando el texto y no se quede «congelada» la ventana.

Este es el código del evento Clicked del botón de analizar:

private async void BtnAnalizar_Clicked(object sender, EventArgs e)
{
    txtResultado.Text = "";

    string tmp = txtTexto.Text;
    if (string.IsNullOrEmpty(tmp))
    {
        MostrarAviso("Por favor indica el texto a analizar de al menos 3 caracteres", esError: true);
        txtTexto.Focus();
        return;
    }

    text = tmp;
    HabilitarBotones(false);

    await Task.Run(() =>
    {
        MostrarAviso("Analizando el texto...", esError: false);
        frase = Frases.Add(text);

        BtnMostrar2.Dispatcher.Dispatch(() =>
        {
            // Inicialmente mostrar todo sin tokens
            BtnMostrar2_Clicked(null, null);
        });
        QuitarAviso();
    });

    HabilitarBotones(true);

En los métodos llamados desde Task.Run se tienen en cuenta el Dispatcher de los controles que se modifican, con idea de que no den problemas al hacerlo entre hilos diferentes.

Este es el código de los métodos QuitarAviso y MostrarAviso que modifican una etiqueta y un StackLayout.

private void QuitarAviso()
{
    LabelAviso.Dispatcher.Dispatch(() => { LabelAviso.IsVisible = false; });
    grbAviso.Dispatcher.Dispatch(() => { grbAviso.BackgroundColor = Colors.Transparent; });
}

private void MostrarAviso(string aviso, bool esError)
{
    grbAviso.Dispatcher.Dispatch(() =>
    {
        if (esError)
        {
            grbAviso.BackgroundColor = Colors.Firebrick;
        }
        else
        {
            grbAviso.BackgroundColor = Colors.SteelBlue;
        }
    });
    LabelAviso.Dispatcher.Dispatch(() =>
    {
        LabelAviso.Text = aviso;
        LabelAviso.IsVisible = true;
    });

Algunas capturas

Aquí tienes un par de capturas de la app para .NET MAUI en funcionamiento, en la figura 1 está funcionando en Windows (usando el expander), en la figura 2 antes de poner el expander y en la figura 3 en un móvil con Android (antes de poner el expander), en iPhone no me funciona (tampoco el resto de los proyectos que tenía, así que, no he podido hacer captura).

Figura 1. En Windows con el expander

Figura 2. En Windows

Figura 3. En Android

Te recomiendo que leas el post anterior para ver cómo crear un cliente de Google Cloud Natural Language y poder usarlo en estos proyectos, en ese post indico que el código es para Visual Basic, pero los pasos a seguir son los mismos para Visual Basic que para C#.


Espero que te sea de utilidad.

Nos vemos.
Guillermo

Google Cloud Natural Language, ejemplo en Visual Basic .NET

Pues eso… aquí te dejo un ejemplo para usar las API de Google Cloud Natural Language, pero para Visual Basic .NET

Con esas API podrás analizar textos (también en español) y ver las palabras que la forman (tokens), su estructura sintáctica, etc.

Nota:
Para usar este código tendrás que crearte una cuenta en Google Cloud, generar una «key» para usarla y poco más, todos los pasos están explicados en este enlace (el código de ejemplo es para C#, pero te servirá.

Pasos para crear un proyecto usando dotnet (cli):

– Abre una ventana de consola (o terminal)
– Posicionarse en la carpeta donde crear el proyecto
– Crear el proyecto
dotnet new console -n <nombre-proyecto>
dotnet new console -lang VB -n <nombre-proyecto>
– Cambiar al directorio del proyecto
cd <nombre-proyecto>
– Añadir el paquete de Google Cloud Natural Language API
dotnet add package Google.Cloud.Language.V1
– Copiar el fichero key.json con las claves y permisos
– Ver estos pasos para crearla:
https://codelabs.developers.google.com/codelabs/cloud-natural-language-csharp#3
– En IAM, añadir la cuenta creada (incluida en el fichero key.json) en +OTORGAR ACCESO
Solo estará la principal y/o las otras añadidas
– Si se ha usado otra cuenta, estará en IAM>Cuentas de Servicio
– Modificar Program.cs (o Program.vb) para usar el código que accede a la API de Natural Language
– Ejecutar el código
dotnet run

Notas:
– Debes crear una variable de entorno en Windows, (lo puedes hacer desde la misma consola) indicando el path donde estará el fichero key.json.
– Lo que yo hago es copiar ese fichero en la carpeta del ejecutable y la variable de entorno la defino de esta forma:
set GOOGLE_APPLICATION_CREDENTIALS=key.json
– Puedes modificar el fichero del proyecto y añadir lo siguiente:

  <ItemGroup>
    <None Update="key.json">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </None>
  </ItemGroup>

El código de ejemplo

'--------------------------------------------------------------------------------
' Ejemplo de Google Cloud Natural Language en Visual Basic .NET (31/ene/23 18.50)
'
' (c)Guillermo Som (Guille), 2023
'--------------------------------------------------------------------------------

Imports System
Imports System.Text
Imports gcl = Google.Cloud.Language.V1
Imports Google.Protobuf.Collections
Imports Google.Cloud.Language.V1.AnnotateTextRequest.Types

'Namespace NaturalLanguageApiDemo
Class Program
    Shared client As gcl.LanguageServiceClient '?

    Shared Sub Main(args As String())
        'Dim text = "El 8 de Febrero voy en bici al Camino de Santiago desde Sarria ¿crees que aguantaré?"
        Dim text = "Probando Google Cloud Natural Language con VB.NET ¿Funcionará esto?"

        Console.WriteLine("Ejemplos de Google.Cloud.Language")
        Console.WriteLine()
        Console.WriteLine("Pruebas de Google Cloud Natural Language en Visual Basic .NET")
        Console.WriteLine()
        Console.WriteLine("  Creando el cliente...")
        client = gcl.LanguageServiceClient.Create()
        Console.WriteLine()

        Dim repitiendo As Boolean = False

        Do

            If repitiendo Then
                Console.WriteLine($"Última: '{text}'")
                Console.WriteLine("Indica la frase que quieres analizar (0 salir, [la última])")
            Else
                Console.WriteLine($"Predeterminada: '{text}'")
                Console.WriteLine("Indica la frase que quieres analizar (0 salir, [predeterminada])")
            End If

            Console.Write("> ")
            Dim resText = Console.ReadLine()

            If Not String.IsNullOrEmpty(resText) Then

                If resText = "0" Then
                    Exit Do
                End If

                text = resText
            End If

            Do
                Console.WriteLine($"Analizar: '{text}'")
                Console.Write("1- Todo con tokens, 2- Todo sin tokens, 3- Solo tokens, 0- nueva frase [2] ? ")
                resText = Console.ReadLine()
                Console.WriteLine()

                If String.IsNullOrEmpty(resText) Then
                    resText = "2"
                End If

                If resText = "1" Then
                    Analizar(text, conTokens:=True)
                ElseIf resText = "2" Then
                    Analizar(text, conTokens:=False)
                ElseIf resText = "3" Then
                    AnalizarTokens(text)
                ElseIf resText = "0" Then
                    Exit Do
                End If

                Console.WriteLine()
            Loop While True

            repitiendo = True
        Loop While True
    End Sub

    Private Shared Sub Analizar(text As String, conTokens As Boolean)
        If client Is Nothing Then
            client = gcl.LanguageServiceClient.Create()
        End If

        Dim document = gcl.Document.FromPlainText(text)
        Dim response As gcl.AnnotateTextResponse

        Try
            response = client.AnnotateText(document, New Features With {
                    .ExtractSyntax = True,
                    .ExtractEntities = True,
                    .ExtractDocumentSentiment = True,
                    .ExtractEntitySentiment = True,
                    .ClassifyText = True
                })
        Catch
            response = client.AnnotateText(document, New Features With {
                    .ExtractSyntax = True,
                    .ExtractEntities = True,
                    .ExtractDocumentSentiment = True,
                    .ExtractEntitySentiment = True
                })
        End Try

        Dim sentiment = response.DocumentSentiment
        Console.WriteLine($"Detected language: {response.Language}")
        Console.WriteLine($"Sentiment Score: {sentiment.Score}, Magnitude: {sentiment.Magnitude}")
        Console.WriteLine("***Entities:")
        Dim entity1 As gcl.Entity = Nothing

        For Each entity0 In response.Entities

            If entity1 Is Nothing Then
                entity1 = entity0
            Else
                If entity0.Equals(entity1) Then Continue For
            End If

            Console.WriteLine($"Entity: '{entity0.Name}'")
            Console.WriteLine($"  Type: {entity0.Type},  Salience: {CInt((entity0.Salience * 100))}%")

            If entity0.Mentions.Count > 0 Then
                Console.WriteLine($"  Mentions: {entity0.Mentions.Count}")

                For Each mention In entity0.Mentions
                    Console.Write($"    Text: '{mention.Text.Content}' (beginOffset: {mention.Text.BeginOffset}),")
                    Console.WriteLine($" Type: {mention.Type}, Sentiment: {mention.Sentiment}")
                Next
            End If

            If entity0.Metadata.Count > 0 Then
                Console.WriteLine($"  Metadata: {entity0.Metadata}")

                If entity0.Metadata.ContainsKey("wikipedia_url") Then
                    Console.WriteLine($"    URL: {entity0.Metadata("wikipedia_url")}")
                End If
            End If
        Next

        Console.WriteLine("***Categories:")

        For Each cat In response.Categories
            Console.WriteLine($"Category: '{cat.Name}' (Confidence: {cat.Confidence})")
        Next

        Console.WriteLine("***Sentences:")

        For Each sentence In response.Sentences
            Console.WriteLine($" Sentence.Text.Content: '{sentence.Text.Content}'")
            Console.WriteLine($"   Sentence.Text.BeginOffset: {sentence.Text.BeginOffset}")
            Console.WriteLine($" Sentence.Sentiment .Magnitude: {sentence.Sentiment.Magnitude}, .Score: {sentence.Sentiment.Score}")
        Next

        If conTokens Then
            Console.WriteLine("***Tokens:")

            For i As Integer = 0 To response.Tokens.Count - 1
                MostrarToken(i, response.Tokens, conContenido:=False)
            Next
        End If
    End Sub

    Private Shared Sub AnalizarTokens(text As String)
        If client Is Nothing Then
            client = gcl.LanguageServiceClient.Create()
        End If

        Dim document = gcl.Document.FromPlainText(text)
        Dim response As gcl.AnnotateTextResponse

        Try
            response = client.AnnotateText(document, New Features With {
                    .ExtractSyntax = True,
                    .ExtractEntities = True,
                    .ExtractDocumentSentiment = True,
                    .ExtractEntitySentiment = True,
                    .ClassifyText = True
                })
        Catch
            response = client.AnnotateText(document, New Features With {
                    .ExtractSyntax = True,
                    .ExtractEntities = True,
                    .ExtractDocumentSentiment = True,
                    .ExtractEntitySentiment = True
                })
        End Try

        AnalizarSentecias(response)
    End Sub

    Private Shared Sub AnalizarSentecias(self As gcl.AnnotateTextResponse)
        Dim index As Integer = 0

        For Each sentence In self.Sentences
            Dim content = sentence.Text.Content
            Dim sentence_begin = sentence.Text.BeginOffset
            Dim sentence_end = sentence_begin + content.Length - 1

            While index < self.Tokens.Count AndAlso self.Tokens(index).Text.BeginOffset <= sentence_end
                MostrarToken(index, self.Tokens, conContenido:=True)
                index += 1
            End While
        Next
    End Sub

    Private Shared Sub MostrarToken(nToken As Integer, tokens As RepeatedField(Of gcl.Token), Optional conContenido As Boolean = True)
        Dim token As gcl.Token = tokens(nToken)
        Console.WriteLine($"{nToken}- Token: Text.Content: '{token.Text.Content}', Lemma: '{token.Lemma}'")

        If token.DependencyEdge.Label = gcl.DependencyEdge.Types.Label.Root Then
            Console.Write($"  **DependencyEdge Label: {token.DependencyEdge.Label}")

            If token.DependencyEdge.HeadTokenIndex <> nToken Then
                Console.Write($", HeadTokenIndex: {token.DependencyEdge.HeadTokenIndex}")
            End If

            Console.WriteLine("**")
        Else
            Console.Write($"  DependencyEdge Label: {token.DependencyEdge.Label}, HeadTokenIndex: {token.DependencyEdge.HeadTokenIndex}")
            Dim tokenDependency = tokens(token.DependencyEdge.HeadTokenIndex)
            Console.WriteLine($" ('{tokenDependency.Text.Content}')")
        End If

        If conContenido Then
            Console.WriteLine($"  PartOfSpeech:")
            Console.Write($"    Tag: {token.PartOfSpeech.Tag},")
            Dim sb = New StringBuilder()

            If token.PartOfSpeech.Aspect <> gcl.PartOfSpeech.Types.Aspect.Unknown Then
                sb.Append($" (Aspect: {token.PartOfSpeech.Aspect},")

                If token.PartOfSpeech.[Case] <> gcl.PartOfSpeech.Types.[Case].Unknown Then
                    sb.Append($" Case: {token.PartOfSpeech.[Case]},")
                End If

                If token.PartOfSpeech.Form <> gcl.PartOfSpeech.Types.Form.Unknown Then
                    sb.Append($" Form: {token.PartOfSpeech.Form},")
                End If

                If sb.ToString().EndsWith(","c) Then
                    sb.Length -= 1
                End If

                sb.Append("),")
            End If

            If token.PartOfSpeech.Gender <> gcl.PartOfSpeech.Types.Gender.Unknown Then
                sb.Append($" (Gender: {token.PartOfSpeech.Gender},")

                If token.PartOfSpeech.Mood <> gcl.PartOfSpeech.Types.Mood.Unknown Then
                    sb.Append($" Mood: {token.PartOfSpeech.Mood},")
                End If

                If token.PartOfSpeech.Number <> gcl.PartOfSpeech.Types.Number.Unknown Then
                    sb.Append($" Number: {token.PartOfSpeech.Number},")
                End If

                If sb.ToString().EndsWith(","c) Then
                    sb.Length -= 1
                End If

                sb.Append("),")
            End If

            If token.PartOfSpeech.Proper <> gcl.PartOfSpeech.Types.Proper.Unknown Then
                sb.Append($" Proper: {token.PartOfSpeech.Proper}")
            End If

            If sb.ToString().Trim().Length > 0 Then
                Console.WriteLine(sb.ToString().TrimEnd(","c))
            End If

            sb.Clear()
            sb.Append("   ")

            If token.PartOfSpeech.Person <> gcl.PartOfSpeech.Types.Person.Unknown Then
                sb.Append($" Person: {token.PartOfSpeech.Person},")
            End If

            If token.PartOfSpeech.Reciprocity <> gcl.PartOfSpeech.Types.Reciprocity.Unknown Then
                sb.Append($" Reciprocity: {token.PartOfSpeech.Reciprocity},")
            End If

            If token.PartOfSpeech.Tense <> gcl.PartOfSpeech.Types.Tense.Unknown Then
                sb.Append($" Tense: {token.PartOfSpeech.Tense},")
            End If

            If token.PartOfSpeech.Voice <> gcl.PartOfSpeech.Types.Voice.Unknown Then
                sb.Append($" Voice: {token.PartOfSpeech.Voice}")
            End If

            If sb.ToString().Trim().Length > 0 Then
                Console.WriteLine(sb.ToString())
            End If
        Else
            Console.WriteLine($"  PartOfSpeech Aspect: {token.PartOfSpeech.Aspect}, Case: {token.PartOfSpeech.[Case]}, Form: {token.PartOfSpeech.Form}")
            Console.WriteLine($"  PartOfSpeech Gender: {token.PartOfSpeech.Gender}, Mood: {token.PartOfSpeech.Mood}, Number: {token.PartOfSpeech.Number}")
            Console.WriteLine($"  PartOfSpeech Person: {token.PartOfSpeech.Person}, Proper: {token.PartOfSpeech.Proper}")
            Console.WriteLine($"  PartOfSpeech Reciprocity: {token.PartOfSpeech.Reciprocity}, Tag: {token.PartOfSpeech.Tag}")
            Console.WriteLine($"  PartOfSpeech Tense:: {token.PartOfSpeech.Tense}, Voice: {token.PartOfSpeech.Voice}")
        End If
    End Sub
End Class
'End Namespace

Una captura

La aplicación en funcionamiento

Código fuente

El código fuente del ejemplo para Visual Basic .NET, así como el de C#, los puedes ver/descargar desde este repositorio en GitHub.

Y esto ha sido todo amigos… 😉

Nos vemos.
Guillermo

Evaluar expresiones (código en Java y C#)

Pues eso… Sí, has leído bien el título: en Java. Y no en JavaScript (aparte de en C#).

Y es que hace unos días, empecé a estudiar esto de Java a raíz que mi hijo David está haciendo un curso de Java (back-end) y era por si le echaba una mano en algunos conceptos, ya que lo que él estudio en su día fue COBOL, algo de Pascal y algo de Visual Basic 6, y claro… los conceptos de POO y esas cosas, como que no las tiene claras.

Y para poder ayudarle (si es que así me lo hace saber), me puse a «trastear» en Java, y de camino he aprendido entre otras cosas, que hay diferencias, algunos grandes, en comparación con C# que es lo más parecido, (con Visual Basic ni te cuento).

Algunas de esas diferencias son a favor de Java, y la mayoría, a favor de C# o si lo prefieres a favor de .NET, seguramente porque lo conozco más.

Pero sea como sea, y peleándome un poco con el código y el IDE, que por cierto estoy usando uno que me parece muy bueno y es gratis: IntelliJ IDEA (Community Edition) de JetBrains, he conseguido hacer algo más o menos operativo y que me está enseñando algunas de esas cosas que ni siquiera sabía que C# las tenía y otras que al parecer C# tiene porque Java las tenía.

Lo que más he echado en falta son las «tuplas», aunque en este código de evaluar expresiones aritméticas he solventado con records, más que nada porque en algunas funciones necesitaba devolver dos valores (seguramente en Java habrá otra forma de hacerlo, pero no la he encontrado). Otra cosa que he echado en falta en Java es las estructuras (tipos de datos definibles, pero por valor).

 

No te voy a explicar «paso a paso» el código ni nada de eso (al menos por ahora), simplemente te voy a decir lo que este evaluador sabe hacer (creo que lo hace bien) y el código lo podrás ver en el repositorio de GitHub.

Quiero comentarte que primero hice una versión usando records para hacer las operaciones de suma, restas, multiplicación y división (basándome en un ejemplo de la documentación de Java), y el último es usando tipos double que además de esas cuatro operaciones hace un par de ellas más: módulo y factorial.

El enlace de GitHub o, mejor dicho, los enlaces son para el código basado en el tipo double, en esos repositorios tienes los enlaces al código fuente que usa los records, tanto para Java como para C#.

 

Lo que hace el evaluador de expresiones

  • Evalúa expresiones entre paréntesis (con varios niveles de anidación).
  • Evalúa primero los operadores multiplicativos (* y x para multiplicar, / y : para dividir y % para el módulo) y después los operadores aditivos (+ para sumar, – para restar).
  • La expresión puede tener espacios, pero al evaluarla se quitan, por tanto: «1 5 * 2» se convierte en «15*2».
  • Si hay un paréntesis de apertura precedido por un dígito o de un paréntesis de cierre, se considera una multiplicación y se pone el signo *.
  • Si hay un paréntesis de cierre seguido de un dígito o de un paréntesis de apertura, se considera una multiplicación y se pone el signo *.
  • Evalúa factoriales (usando el carácter «!»), tanto de números enteros positivos (naturales) como números negativos con parte decimal.
  • El valor de la factorial para números no naturales se calcula usando la función gamma basada en un código adaptado de un ejemplo de StackOverflow.

 

El código de Java y C# en GitHub

Estos son los enlaces del código fuente que tengo publicado en GitHub:

EvaluarExpresiones-java y EvaluarExpresiones-csharp.

Espero que te sea de utilidad.

Nos vemos.
Guillermo

Trucos para .NET MAUI (segunda parte)

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.

<Frame>
    <VerticalStackLayout Spacing="25" Margin="4">

¿Fácil verdad?

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.

Nota:
En esta «issue de MAUI» dicen que se podrá hacer: Desktop: set window size and position #771 (pero ni idea de cómo o cuando estará disponible).

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.

public App()
    {
         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 = new AppShell();
    }

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; //1800

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

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

Generar las clases (de VB o C#) de una tabla de SQL Server o Access (mdb)

Pues eso… este post es para tener actualizada la utilidad CrearClaseTabla que en su día (allá por 2004) creé para generar o crear clases para acceder a una base de datos de SQL Server o de Access.

La idea de esta utilidad (la aplicación y la DLL que es la que hace el trabajo) es crear clases de Visual Basic o C# de cada tabla de la base de datos, con idea de facilitar el acceso por código a esas tablas.

En la última actualización de hoy 1 de octubre de 2022 se contempla, entre otras cosas, la definición de variables asignadas sin indicar el tipo (inferencia de tipos) además de convertir adecuadamente las conversiones de tipo de Visual Basic a C# (aunque en el código solo uso CInt).

Nota:
He creado el proyecto para .NET 6.0 (Windows) y está disponible en GitHub: gsCrearClasesTablas.
Por ahora el código es el mismo en este nuevo proyecto como en el que referencio en este post/artículo que es para .NET Framework 4.8.1

El código «base» que utilizo es el que yo uso con Visual Basic y la clase CrearClase apoyada de ConvLag se encarga de generar el código de Visual Basic o el de C#.

Por ejemplo, el código que te muestro primero, en el generador de clases lo defino como te muestro en el segundo bloque de código:

Este es el código en que me he basado:

        cmd.Transaction = tran
        cmd.ExecuteNonQuery()

        ' Si llega aquí es que todo fue bien,
        ' por tanto, llamamos al método Commit.
        tran.Commit()

        msg = "Se ha actualizado el Cliente correctamente."

    Catch ex As Exception
        msg = $"ERROR: {ex.Message}"
        ' Si hay error, deshacemos lo que se haya hecho.
        Try
            If tran IsNot Nothing Then
                tran.Rollback()
            End If
        Catch ex2 As Exception
            msg = $" (ERROR RollBack: {ex.Message})"
        End Try

    Finally
        con.Close()
    End Try

End Using

Return msg

Este es el código interno que uso en el conversor (el método generarClase):
En los comentarios está el código mostrado antes y el equivalente para generar el código de VB o de C#.

sb.AppendLine()
'         cmd.Transaction = tran
sb.AppendFormat("            {0}{1}", ConvLang.Asigna("cmd.Transaction", "tran"), vbCrLf)
'         cmd.ExecuteNonQuery()
sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("cmd.ExecuteNonQuery()"), vbCrLf)
sb.AppendLine()
'         ' Si llega aquí es que todo fue bien,
'         ' por tanto, llamamos al método Commit
sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" Si llega aquí es que todo fue bien,"), vbCrLf)
sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" por tanto, llamamos al método Commit."), vbCrLf)
'         tran.Commit()
sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("tran.Commit()"), vbCrLf)
sb.AppendLine()
'         msg = "Se ha actualizado el Cliente correctamente."
sb.AppendFormat("            {0}{1}", ConvLang.Asigna("msg", """Se ha actualizado un " & nombreClase & " correctamente."""), vbCrLf)
sb.AppendLine()
'     Catch ex As Exception
sb.AppendFormat("            {0}{1}", ConvLang.Catch("ex", "Exception"), vbCrLf)
'         msg = $"ERROR: {ex.Message}"
sb.AppendFormat("              {0}{1}", ConvLang.Asigna("msg", "$""ERROR: {ex.Message}"""), vbCrLf)
'         ' Si hay error, deshacemos lo que se haya hecho
sb.AppendFormat("              {0}{1}", ConvLang.Comentario(" Si hay error, deshacemos lo que se haya hecho."), vbCrLf)
'         Try
sb.AppendFormat("              {0}{1}", ConvLang.Try(), vbCrLf)
' Añadir comprobación de nulo en el objeto tran     (17-abr-21)
'   If tran IsNot Nothing Then
sb.AppendFormat("                  {0}{1}", ConvLang.If("tran", "IsNot", "Nothing"), vbCrLf)
'             tran.Rollback()
sb.AppendFormat("                        {0}{1}", ConvLang.Instruccion("tran.Rollback()"), vbCrLf)
' End If
sb.AppendFormat("                  {0}{1}", ConvLang.EndIf, vbCrLf)
'         Catch ex2 As Exception
sb.AppendFormat("              {0}{1}", ConvLang.Catch("ex2", "Exception"), vbCrLf)
'             msg &= $" (ERROR RollBack: {ex.Message})"
sb.AppendFormat("               {0}{1}", ConvLang.Asigna("msg", "$""ERROR RollBack: {ex2.Message}"""), vbCrLf)
'         End Try
sb.AppendFormat("              {0}{1}", ConvLang.EndTry(), vbCrLf)
sb.AppendLine()
sb.AppendFormat("            {0}{1}", ConvLang.Finally, vbCrLf)
' If Not (con is nothing) then
sb.AppendFormat("              {0}{1}", ConvLang.If("", "Not", "(con Is Nothing)"), vbCrLf)
'     con.Close()
sb.AppendFormat("                  {0}{1}", ConvLang.Instruccion("con.Close()"), vbCrLf)
' End If
sb.AppendFormat("              {0}{1}", ConvLang.EndIf, vbCrLf)
'     End Try
sb.AppendFormat("            {0}{1}", ConvLang.EndTry(), vbCrLf)
sb.AppendLine()
' End Using
sb.AppendFormat("            {0}{1}", ConvLang.EndUsing(), vbCrLf)
sb.AppendLine()
' Return msg
sb.AppendFormat("            {0}{1}", ConvLang.Return("msg"), vbCrLf)

Y el código generado de Visual Basic sería como te he mostrado arriba y el de C# sería más o menos este:

cmd.Transaction = tran;
cmd.ExecuteNonQuery();

// Si llega aquí es que todo fue bien,
// por tanto, llamamos al método Commit.
tran.Commit();

msg = "Se ha actualizado un Producto correctamente.";

}catch(Exception ex){
  msg = $"ERROR: {ex.Message}";
  // Si hay error, deshacemos lo que se haya hecho.
  try{
      if(tran  !=   null ){
            tran.Rollback();
      }
  }catch(Exception ex2){
   msg = $"ERROR RollBack: {ex2.Message}";
  }

finally{
  if(  !  (con  ==   null )){
      con.Close();
  }
}

}

return msg;

Como ves, no está bien formateado, (es el código generado directamente) pero si lo pegas en Visual Studio te lo formateará bien y lo coloreará mejor 😉

Y para muestra, ese trozo de código en un fichero abierto en Visual Studio 2022:
(Aunque todo hay que decirlo, en VB lo formatea bien, aunque solo sea un fichero abierto directamente (sin formar parte de ningún proyecto) mientras que en C# le he tenido casi que dar el formato manualmente, en fin…)

    cmd.Transaction = tran;
    cmd.ExecuteNonQuery();

    // Si llega aquí es que todo fue bien,
    // por tanto, llamamos al método Commit.
    tran.Commit();

    msg = "Se ha actualizado un Producto correctamente.";

}
catch(Exception ex)
{
      msg = $"ERROR: {ex.Message}";
      // Si hay error, deshacemos lo que se haya hecho.
    try
    {
        if (tran != null) 
        {
            tran.Rollback();
        }
    }
    catch(Exception ex2)
    {
        msg = $"ERROR RollBack: {ex2.Message}";
    }

    finally
    {
        if (!(con == null))
        {
          con.Close();
        }
    }
}

Pero la idea es que te quedes con lo que la clase hace.

También es cierto que yo suelo generar el código para Visual Basic y es lo que realmente he probado más, hoy he estado viendo cómo lo generaría para C# y he estado haciendo algunas correcciones (que he indicado en el fichero Revisiones.md publicado con GitHub).

Lo publicado originalmente en elGuilel.info

Los enlaces originales en www.elguille.info son estos:
– La página principal de la utilidad: Generar clases para acceder a una tabla.
– La página con el código y esas cosas: Utilidad para generar clases para acceder a una tabla.
– La página de actualización de cómo conseguir el código fuente: Esta me da error y estaba en CodePlex, ahora está en GitHub.

El final (del post)

Una captura de la utilidad tal como la tengo a día 1 de octubre de 2022.

Figura 1. La utilidad en funcionamiento a día de hoy 1 de octubre de 2022

Y esto es todo amigo (o amiga), ya sabes, si quieres participar en el proyecto para mejorarlo, puedes hacerlo, creo que en algún sitio indico cómo avisarme de los errores que encuentres y cómo actualizar el fichero Revisiones.txt que ahora es Revisiones.md.

Y si quieres usarlo sin más aportaciones, estaría bien que hicieras una pequeña aportación monetaria en PayPal (no es obligatorio, pero es de agradecer).

En breve publicaré en GitHub el ejecutable compilado con .NET Framework 4.8.1.

Nota:
Ya está publicado: gsCrearClaseTabla_20221001_1523.

Y ya sabes, si quieres ver el código fuente, está en el proyecto de GitHub (CrearClaseTabla).

Por cierto, en el proyecto (los dos) he incluido un fichero de nombre seguro (strong name) para firmar los ensamblados, ese fichero (elGuille_compartido.snk) lo puedes usar «libremente» (ya sabes todo está con la licencia MIT) para firmar los ensamblados con nombre seguro.

Espero que te sirva de utilidad.

Nos vemos.
Guillermo

P.S.
Sería interesante convertir el proyecto para .NET 6 (o 7) y también usando el código completamente en C#.
Actualmente está creado para usar con .NET Framework 4.8.1 y escrito enteramente en Visual Basic.

P.S.2
Ya está creado el proyecto para .NET 6.0 (net6.0-windows) y publicado en GitHub (gsCrearClasesTablas).

Cambiar el tamaño de la ventana de Windows (WinUI) en app de .NET MAUI

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;

public partial class App : Application
{
    public App()
    {
         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 = new AppShell();
    }
}

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.

Nos vemos.
Guillermo

P.S.
El código de ejemplo en GitHub: Cambiar Tamaño de la ventana de Windows (WinUI) con .NET MAUI.

Cambiar el tamaño de la ventana de Windows (UWP) en app de Xamarin.Forms

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>
/// <param name="e">Details about the launch request and process.</param>
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    Frame rootFrame = Window.Current.Content as Frame;

    // 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 = new Frame();

        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 = new Size(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.

using System;
using CambiarTamañoWindows.Services;
using CambiarTamañoWindows.Views;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;

namespace CambiarTamañoWindows;

public partial class App : Application
{

    public App()
    {
        InitializeComponent();

        DependencyService.Register<MockDataStore>();
        MainPage = new AppShell();
    }

    public static double WindowsWidth { get; } = 1200;
    public static double WindowsHeight { get; } = 900;

    protected override void OnStart()
    {
    }

    protected override void OnSleep()
    {
    }

    protected override void OnResume()
    {
    }
}

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

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
       <LangVersion>latest</LangVersion>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Xamarin.Forms" Version="5.0.0.2196" />  
    <PackageReference Include="Xamarin.Essentials" Version="1.7.0" />
  </ItemGroup>
</Project>

Y ahora el código de la parte del constructor:

namespace CambiarTamañoWindows.UWP
{
    public sealed partial class MainPage
    {
        public MainPage()
        {
            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 = new Size(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:

public partial class App : Application
{

    public App()
    {
        InitializeComponent();

        DependencyService.Register<MockDataStore>();
        MainPage = new AppShell();
    }

    public double WindowsWidth { get; } = 1200;
    public double WindowsHeight { get; } = 900;
}

El código del constructor de MainPage sería este otreo:

namespace CambiarTamañoWindows.UWP
{
    public sealed partial class MainPage
    {
        public MainPage()
        {
            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 = new Size(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 😉

Gracias por adelantado.

Nos vemos.
Guillermo

P.S.
El código en gitHub: CambiarTamañoWindows-xamarin.

Serializar/deserializar con Json.Serialization (ejemplo para C#)

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")]
public Dictionary<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>
/// <param name="fileName">El path del fichero a leer y devolver el contenido.</param>
/// <returns>El objeto leído del fichero indicado.</returns>
private static AnchoColumnas Load(string fileName)
{
    // Abrir el fichero para leer, compartido para lectura y escritura.
    using var stream = new FileStream(fileName, 
                                      FileMode.OpenOrCreate, 
                                      FileAccess.Read, 
                                      FileShare.ReadWrite);
    // Si tiene contenido, deserializarlo, si no, devolver un valor nulo.
    if (stream.Length > 0)
        return JsonSerializer.Deserialize<AnchoColumnas>(stream);
    else
        return null;
}

/// <summary>
/// Guarda los datos de tipo AnchoColumnas indicado.
/// </summary>
/// <param name="anchosColumnas"></param>
/// <param name="fileName"></param>
/// <returns></returns>
private static void Save(AnchoColumnas anchosColumnas, string fileName)
{
    // Abrir el fichero para escribir, compartido para lectura y escritura.
    using var stream = new FileStream(fileName, 
                                      FileMode.OpenOrCreate, 
                                      FileAccess.Write, 
                                      FileShare.ReadWrite);
    // Que se indente el contenido.
    var options = new JsonSerializerOptions { 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>
/// <param name="anchosColumnas"></param>
public static void 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>
public static AnchoColumnas 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:

private static AnchoColumnas _AnchosColumnas = null;
/// <summary>
/// Los anchos de las columnas de los listados.
/// </summary>
public static AnchoColumnas 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)
If AnchoColumnas.AnchosColumnas.Anchos.ContainsKey(value.ToString()) = False Then
    AnchoColumnas.AnchosColumnas.Anchos.Add(value.ToString(),
                                            New Dictionary(Of Integer, Integer))
End If
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 End If

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.

Private Sub lvDatos_ColumnWidthChanged(sender As Object, e As DataGridViewColumnEventArgs) Handles lvDatos.ColumnWidthChanged
    ' Cambiar el ancho de las columnas de los totales       (10/mar/22 04.28)
    ' al cambiar el del principal.
    If inicializando Then Return

    ' Asignar y guardar los valores.                        (22/abr/22 20.39)
    Dim value = TipoListado.ToString()
    With lvDatos
        If AnchoColumnas.AnchosColumnas.Anchos.ContainsKey(value) = False Then
            AnchoColumnas.AnchosColumnas.Anchos.Add(value, New Dictionary(Of Integer, Integer))
        End If
        ' 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)
    End With
End Sub

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 😉

Nos vemos.
Guillermo

Saber las unidades externas (USB pendrive fijo o extraíble)

Pues eso… yo pensaba que todas las unidades (de tipo pendrive) USB devolverían un valor del tipo DriveType.Removable, pero resulta que no. Al igual que ocurre con los discos duros conectados por USB, los pendrives también pueden ser de tipo fijo (DriveType.Fixed).

Y lo que te voy a mostrar es el código para C# y Visual Basic (usando .NET 5.0 con Visual Studio 2019) para saber todas las unidades conectadas por USB (sean fijas o extraíbles), además de una función para saber si el path indicado está o no en una unidad extraíble.

También incluyo un ejemplo de cómo saber las unidades (y el tipo de unidad que es) usando el «clásico» método para saber las unidades instaladas con DriveInfo.GetDrives().

En la siguiente captura puedes ver el programa funcionando en mi equipo.

Imagen 1. El programa funcionando.

En mi equipo tengo conectado 2 discos duros por usb (letras S y T), un pendrive de tipo fijo (letra F) y uno de tipo extraíble (letra G).

En la primera lista (usando el método GetDrives de la clase DriveInfo) el único que se muestra como «extraíble» es el disco G, el resto se muestran como fijos (fixed).
En la segunda lista se muestran las unidades extraíbles, sean o no fijas.

Ya sin más rollos te muestro el código tanto para C# como para Visual Basic.

El código lo puedes descargar de GitHub (UnidadesExternas), pero si quieres crearlo por tu cuenta, decirte que he tenido que añadir una referencia al paquete de Nuget System.Management versión 5.0 ya que estos proyectos los he creado con Visual Studio 2019 y esa versión de Visual Studio no utiliza versiones posteriores a .NET 5.0.

El tipo de proyecto es Consola de Windows, aunque he tenido que cambiar el tipo del proyecto, ya que al elegir que sea para .NET 5.0 ha intentado usarlo para cualquier plataforma.
En el fichero del proyecto (de C# o de VB) busca <TargetFramework> y cambia net5.0 por net5.0-windows, ya que System.Management solo se puede usar en el sistema operativo Windows.

 

Nota:
Comentarte que el código (de C#) está basado en dos ejemplos encontrados en la red y de esos dos códigos de ejemplo he sacado el código del método GetUsbDriveLetters.
Estos son los enlaces que he usado:
El primero es prácticamente el usado en ese código, pero añadiendo la comprobación de que MediaType también pueda ser External, que saqué del segundo.
https://stackoverflow.com/a/31560283/14338047
https://stackoverflow.com/a/10018438/14338047

 

Código de C# de la utilidad para saber las unidades externas

public class USBUtil
{
    /// <summary>
    /// Comprueba si es una unidad externa.
    /// </summary>
    /// <param name="elPath">Path completo del que se extraerá la letra de unidad.</param>
    /// <returns></returns>
    public static bool EsUnidadExterna(string elPath)
    {
        var disco = Path.GetPathRoot(Path.GetFullPath(elPath));
        var usbD = GetUsbDriveLetters();
        return usbD.Contains(disco);
    }

    // Código basado en dos ejemplos de "la red".
    // https://stackoverflow.com/a/31560283/14338047
    // https://stackoverflow.com/a/10018438/14338047

    /// <summary>
    /// Las letras de las unidades externas conectadas por USB.
    /// </summary>
    /// <returns></returns>
    public static List<string> GetUsbDriveLetters()
    {
        // Hay que usar External para que también tenga en cuenta los USB de tipo fijo.
        var usbDrivesLetters = from drive in new ManagementObjectSearcher("select * from Win32_DiskDrive WHERE MediaType like '%External%' OR InterfaceType='USB'").Get().Cast<ManagementObject>()
                               from o in drive.GetRelated("Win32_DiskPartition").Cast<ManagementObject>()
                               from i in o.GetRelated("Win32_LogicalDisk").Cast<ManagementObject>()
                               select string.Format("{0}\\", i["Name"]);

        return usbDrivesLetters.ToList();
    }

}

 

Código de Visual Basic de la utilidad para saber las unidades externas

Public Class USBUtil

    ''' <summary>
    ''' Comprueba si es una unidad externa.
    ''' </summary>
    ''' <param name="elPath">Path completo del que se extraerá la letra de unidad.</param>
    ''' <returns></returns>
    Public Shared Function EsUnidadExterna(elPath As String) As Boolean
        Dim disco = Path.GetPathRoot(Path.GetFullPath(elPath))
        Dim usbD = GetUsbDriveLetters()
        Return usbD.Contains(disco)
    End Function

    ''' <summary>
    ''' Las letras de las unidades externas conectadas por USB.
    ''' </summary>
    ''' <returns></returns>
    Public Shared Function GetUsbDriveLetters() As List(Of String)
        ' Hay que usar External para que también tenga en cuenta los USB de tipo fijo.
        Dim usbDrivesLetters = From drive In New ManagementObjectSearcher("select * from Win32_DiskDrive WHERE MediaType like '%External%' OR InterfaceType='USB'").[Get]().Cast(Of ManagementObject)()
                               From o In drive.GetRelated("Win32_DiskPartition").Cast(Of ManagementObject)()
                               From i In o.GetRelated("Win32_LogicalDisk").Cast(Of ManagementObject)()
                               Select String.Format("{0}\", i("Name"))
        Return usbDrivesLetters.ToList()
    End Function

 

Nota:
Debes añadir importación de los espacios de nombres:
System
System.Collections.Generic
System.IO
System.Linq
System.Management (de NuGet)

 

Código de ejemplo usar estas los métodos de USBUtil.

class Program
{
    static void Main(string[] args)
    {
        Console.Title = "Ejemplo de Visual C# usando .NET 5.0 (net5.0-windows) y System.Management Version=5.0.0";

        Console.WriteLine("Mostrar las unidades usando DriveInfo.GetDrives().");
        foreach (var dr in DriveInfo.GetDrives())
            Console.WriteLine("Unidad: {0}, tipo: {1}", dr.Name, dr.DriveType);

        Console.WriteLine();

        Console.WriteLine("Mostrar las unidades extraíbles.");
        var usb = USBUtil.GetUsbDriveLetters();
        foreach (var s in usb)
            Console.WriteLine("{0}", s);

        Console.WriteLine();
        Console.ReadKey();
    }

Module Program
    Sub Main(args As String())
        Console.Title = "Ejemplo de Visual Basic usando .NET 5.0 (net5.0-windows) y System.Management Version=5.0.0"

        Console.WriteLine("Mostrar las unidades usando DriveInfo.GetDrives().")
        For Each dr In DriveInfo.GetDrives()
            Console.WriteLine("Unidad: {0}, tipo: {1}", dr.Name, dr.DriveType)
        Next
        Console.WriteLine()

        Console.WriteLine("Mostrar las unidades extraíbles.")
        Dim usb = USBUtil.GetUsbDriveLetters()

        For Each s In usb
            Console.WriteLine("{0}", s)
        Next

        Console.WriteLine()
        Console.ReadLine()
    End Sub
End Module

Y esto es todo, espero te resulte de utilidad 😉

Nos vemos.
Guillermo