Archivo de la etiqueta: tutorial

Cómo refrescar los datos en aplicaciones de Xamarin.Forms o .NET MAUI

Pues eso… con el título de este post: Cómo refrescar los datos en aplicaciones de Xamarin.Forms o .NET MAUI, aparte de referirme que es para apliciones multiplataforma/multidispositivos creadas con Xamarin.Forms o .NET MAUI, me refiero a esos casos en los que quiero que se muestre un mensaje (por ejemplo en el texto de una etiqueta) mientras la aplicación hace cosas que pueden tardar un poco, como leer los datos de una base de datos o contar hasta cientocuincuentamilmillonesdetrillones, por decirte algo 😉

En .NET Framework / aplicaciones de Windows.Forms, yo suelo usar el fatídico (para algunos) Application.DoEvents(), que sí, que dicen que usando el Thread.Sleep se supone que hace lo mismo, pero yo te digo que no, a mí no me ha funcionado nunca.

Con la aplicación mobile en la que estoy enfrascado desde hace ya unos 3 meses, intenté el Sleep, intenté crear/usar un temporizador (otra de las formas en que hago con .NET Framework esa pequeña pausa para refrescar), pero nada de nada… Probé haciendo los métodos asíncronos para que fuesen «agüeitable» (async y await), pero nada de nada…

Sin embargo ayer, buscando en la red de redes (Inernet por si no sabías que así se le llama algunas veces), me encontré con una consulta en la que respondían eso que tanto estaba buscando saber cómo hacer, y la respuesta la encontré, (casi como de costumbre), en stackoverflow, concretamente aquí.

Y es usando Task.Delay(...) a la que tenemos que indicar los milisegundos de espera.
En esa respuesta indican dos formas de hacerlo: de forma asíncrona y de forma síncrona, decirte que la que a mí me ha funcionado es la asíncrona, la otra, como si miraras al cielo esperando ver pasar un elefante rosa… por decir algo… Vamos, que ni de coña esperaba…

Y como he visto que funcionaba, me he creado un método compartido en la clase App para que me sea fácil usarla desde cualquier parte de la aplicación, a ese método lo he llamdo Refrescar y recibe un parámetro con los milisegundos que quieres esperar antes de seguir, yo suelo usar el valor 300, que es el que casi siempre uso en los temporizadores que pongo en las aplicaciones de escritorio creadas con .NET Framework.
Este es el código de ese método (en C# ya que por ahora las aplicaciones de Xamarin.Forms / .NET MAUI son (y segurián siendo solo) para el cochambros lenguaje ese de los puntos y comas.

Y si te ha molestado que diga cochambroso lenguaje, de verdad que lo siento, pero… es lo que me parece a mí, al menos en la forma que yo lo uso, es una pequeña caca comparado con Visual Basic. Ya sabes: cochambros es lleno de mugre o cochambre que viene de cocho, puerco… ¡UF! me vas a odiar como seas fanático del C#, pero es lo que hay, es mi opinión, pero con fundamentos.

El código

Bueno, a lo que vamos, este es el código:

/// <summary>
/// Hacer una pequeña pausa para refrescar.
/// </summary>
/// <param name="intervalo">El tiempo que hay que esperar (en milisegundos).</param>
async public static Task Refrescar(int intervalo = 300)
{
    await Task.Delay(intervalo);
}

El valor predeterminado es de 300 milisegundos, es decir, menos de un tercio de segundo, incluso con 100 iría bien, pero…

Cómo lo utilizo

En uno de los casos, tengo una etiqueta en la que muestro el total de datos que leo de la base de datos, mientras se hace la búsqueda muestro un mensaje diciendo algo como: Leyendo los datos…, hago la pausa, (se refreca el contenido de la etiqueta) y mientras llamo al método que lee los datos, en el que actualizo esa etiqueta con los datos mostrados, etc.

LabelInfoReservas.Text = $"Leyendo las reservas de '{ElCliente.Nombre}'...";

// refrescar...
//await Task.Delay(300);
await App.Refrescar();

await asignarLasReservas();

En la siguiente captura, puedes verlo (me ha dado tiempo a hacerla a pesar de que había pocos datos que leer porque, esa es la impresión que a mí me da, las aplicaciones para Windows-UWP de Xamari.Forms / .NET MAUI son algo lentas… en ocasiones muuuucho más lentas que las aplicaciones para escritorio hechas con .NET Framework 4.8. Tanto que esta app móvil no podremos usarla al 100% en la playa porque hay poca cobertura móvil (de datos) que ya se hace insufrible utilizarla, y en este caso no creo que sea porque está hecha con C# 😉

Captura de la app con el mensaje mientras lee los datos de la base de datos.

Y ya está… eso es todo, simple, ¿verdad? pues… sí… 😉

Nos vemos.
Guillermo

Acceder a los recursos definidos en ResourceDictionary o Application.Resources desde código (C#) (Xamarin.Forms y NET MAUI)

Pues eso… es alqo que me ha estado dando un poco la lata en las aplicaciones de Xamarin.Forms, y es acceder a los recursos definidos en el fichero App.xaml tanto dentro de Application.Resources como en las definiciones de ResourceDictionary.

Aquí te explico cómo hacerlo en los dos casos, además de usar un fichero externo con las definiciones de los recursos.

 

Contenido:

 

Empezaré con las definiciones directas en los recursos de App.xaml.

Acceder desde código a las definiciones de recursos definidos en App.xaml

 —

Acceder desde código a las definiciones de Application.Resources

Para acceder a los recursos definidos en Application.Resources desde código es simple (al menos cuando se sabe cómo 😉 ).
Por ejemplo, si tenemos dos recursos definidos, uno ColorAzul1 y el otro ColorAzul2, de esta forma:

<Application.Resources>
    <Color x:Key="ColorAzul">#0073cf</Color>
    <Color x:Key="ColorRojo">Firebrick</Color>
</Application.Resources>

Si queremos usar uno u otro desde código dependiendo de alguna condición, por ejemplo que estemos usando la app en Android o en iOS y que ocurra alguna otra condición (ver nota), podemos hacerlo de esta forma:

if (esUnaPrueba)
    LabelInternet.TextColor = (Color)Application.Current.Resources["ColorAzul"];
else
    LabelInternet.TextColor = (Color)Application.Current.Resources["ColorRojo"];

Como ves en el código a los recursos definidos en Application.Resources se accede usando Application.Current.Resources["key del recurso"];

El cast usando en el código de ejemplo es necesario ya que el valor devuelto por ese elemento de la colección Resources es de tipo object.
Esa forma de hacerlo la conocí gracias a esta entrada en los foros de Xamarin.

Nota: Lo de que ocurra alguna otra condición es porque en los recursos podemos indicar para qué plataforma lo definimos. Aunque para el caso de los colores no sé muy bien como se haría, para el resto puedes ver esto.

 

Acceder desde código a las definiciones de ResourceDictionary

Por otro lado, si el recurso lo tenemos en una rama de ResourceDictionary, por ejemplo de esta forma:

    <ResourceDictionary>
        <Color x:Key="Color2Azul">#0073cf</Color>
        <Color x:Key="Color2Rojo">Firebrick</Color>
    </ResourceDictionary>
</Application.Resources>

Para acceder a esos recursos definidos en ResourceDictionary desde el código de C# lo tendrás que hacer de esta otro forma:

if (esAzul)
    LabelInternet2.SetDynamicResource(Label.TextColorProperty, "Color2Azul");
else
    LabelInternet2.SetDynamicResource(Label.TextColorProperty, "Color2Rojo");

El truco para usar esa otro forma, lo saqueé del mismo post que te indiqué antes, pero estaba abajo del todo, concretamente de aquí.
A lo mejor hay otra forma, pero… a mí me ha servido esta que te muestro.

 

Ahora toca explicarte cómo agregar ficheros de recursos (ResourceDictionary) y usarlos directamente en los recursos del fichero App.Xaml.

Definir recursos (ResourceDictionary) en fichero separado y usarlo en App.xaml

También puedes usar esos ficheros de recursos desde una página concreta.

Ahora también te lo explicaré, que a mí me da mucho coraje cuando se comenta algo así en un post y después no se explica porque se supone que se sabe cómo hacerlo… y aunque puede que sepas cómo hacerlo (eso hasta yo lo sabía hace unos cuantos años cuando empecé con todo esto de XAML, hará al menos 16 años), puede que hayas encontrado este post al buscar cómo hacer eso concretamente y no el resto de cosas que estoy explicando.

Crear un fichero XAML de recursos del tipo ResourceDictionary

En el proyecto añade un nuevo fichero del tipo XAML, yo no he visto cómo agregar uno directamente desde la ventana de agregar nuevo elemento al proyecto, así que, puedes agregar un fichero de texto y después cambiarle la extensión de .txt a .xaml 😉
En la figura 1 puedes ver más claro cómo agregar ese fichero.

Figura 1. Añadir un nuevo fichero al proyecto.

Nota: Después de agregar el fichero y cambiar la extensión (ya sea a la hora de crearlo como es el ejemplo de la figura 1 o si le cambias posteriormente la extensión, es recomendable cerrarlo y después abrirlo, si no, el Intellisense no se cosca de que es del tipo que tiene la extensión. Esto también es válido para ficheros de código al que inicialmente lo has creado como .TXT y después lo cambias a .CS.

Ese fichero estará vacío, así que… habrá que ponerle algo de código, concretamente este que te muestro para que sea un fichero válido del tipo ResourceDictionary.

<?xml version="1.0" encoding="utf-8"?>
<ResourceDictionary xmlns="http://xamarin.com/schemas/2014/forms"
                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">

</ResourceDictionary>

Aquí voy a definir algunas cosas para ver cómo funciona, tanto en modo diseño (en el código XAML de las páginas) como desde el código (en estos ejemplos solo de C# que es lo que me permite usar loss proyectos de Xamarin.Forms.
Aunque lo mismo hago pruebas con aplicaciones del tipo UWP que ahí sí se pueden crear proyetos de C# o de mi querido Visual Basic 😉

En ese fichero de recursos agrega las siguientes definiciones de colores y estilos de etiquetas para que quede como te muestro a continuación.

<?xml version="1.0" encoding="utf-8"?>
<ResourceDictionary xmlns="http://xamarin.com/schemas/2014/forms"
                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">

    <Color x:Key="Color3Azul">#0073cf</Color>
    <Color x:Key="Color3Rojo">Firebrick</Color>
    <Color x:Key="Color3Blanco">White</Color>

    <Style x:Key="LabelEjemplo3" TargetType="{x:Type Label}">
        <Setter Property="FontSize" Value="Small"/>
        <Setter Property="FontAttributes" Value="None" />
        <Setter Property="HorizontalTextAlignment" Value="Start"/>
        <Setter Property="HorizontalOptions" Value="FillAndExpand"/>
        <Setter Property="Padding" Value="4"/>
        <Setter Property="TextColor" Value="Green"/>
        <Setter Property="BackgroundColor" Value="{DynamicResource Key=Color3Blanco}"/>
    </Style>
    <Style x:Key="LabelEjemplo3Azul" TargetType="{x:Type Label}">
        <Setter Property="FontSize" Value="Small"/>
        <Setter Property="FontAttributes" Value="Italic" />
        <Setter Property="HorizontalTextAlignment" Value="Start"/>
        <Setter Property="HorizontalOptions" Value="FillAndExpand"/>
        <Setter Property="Padding" Value="4"/>
        <Setter Property="TextColor" Value="{StaticResource Color3Azul}"/>
        <Setter Property="BackgroundColor" Value="{StaticResource Color3Blanco}"/>
    </Style>
    <Style x:Key="LabelEjemplo3Rojo" TargetType="{x:Type Label}">
        <Setter Property="FontSize" Value="Small"/>
        <Setter Property="FontAttributes" Value="Bold" />
        <Setter Property="HorizontalTextAlignment" Value="Start"/>
        <Setter Property="HorizontalOptions" Value="FillAndExpand"/>
        <Setter Property="Padding" Value="4"/>
        <Setter Property="TextColor" Value="{StaticResource Color3Rojo}"/>
        <Setter Property="BackgroundColor" Value="{StaticResource Color3Blanco}"/>
    </Style>

</ResourceDictionary>

 

Usar un fichero de recursos (ResourceDictionary) desde una página

Y con eso puedes hacer lo siguiente para incluir el fichero de recursos en una página concreta.
Se supone que la página está en una carpeta (en mi caso en la carpeta elGuille) y el fichero de recursos está en el raíz del proyecto. Por tanto tengo que usar ../ para acceder al fichero que está en un path superior. Esto es como cuando accedes a los ficheros, así que no creo que tengas problemas para entenderlo… o eso espero, porque en esto sí que no voy a profundizar 😉

<ContentPage.Resources>
    <ResourceDictionary Source="../ResourceDictionaryElGuille.xaml"/>
</ContentPage.Resources>

Nota: Si estuviera en otra carpeta, tendrás que indicarlo en el path de la propiedad Source. Por ejemplo si la carpeta está en el raíz del proyecto y se llama Recursos, el valor de Source quedaría así: Source="/Recursos/ResourceDictionary2.xaml".

 

Usar por código un recurso (estilo) definido en ResourceDictionary.

Para usar, en este ejemplo, un estilo definido, habría que hacerlo de esta forma:

if (usarEstiloAzul)
    LabelInternet3.SetDynamicResource(Label.StyleProperty, "LabelEjemplo3Azul");
else
    LabelInternet3.SetDynamicResource(Label.StyleProperty, "LabelEjemplo3Rojo");

Es decir, como en el caso de los colores, pero en lugar de usar TextColorProperty, es decir, una propiedad, uso StyleProperty para indicar que es un estilo lo que quiero aplicar desde el fichero de recursos.

 

Por último voy a explicarte cómo agregar ese fichero de recursos (ResourceDictionary) al fichero App.xaml y así poder usarlo en toda la aplicación.

Usar un fichero de recursos (ResourceDictionary) en App.xaml

Seguramente esto parece no tener mucho sentido, ya que si defines los recursos directamente en el fichero App.xaml ¿por qué hacerlo en otro fichero?

En mi caso, la respuesta es la siguiente:
Yo tengo un proyecto de Xamarin Forms que define las clases a usar en la aplicación móvil (Android, iOS y UWP), llamaré Proyecto1 a ese proyecto base (el que se usa desde los proyectos específicos de cada plataforma).

Ahora creo otro proyecto móvil (que llamaré Proyecto2) que tiene también como punto de entrada el fichero App (es lo habitual) y que usa la DLL del proyecto anterior (Proyecto1). Lo hago así, porque la funcionalidad es la misma, pero por circunstacias que no viene al caso profundizar mucho en ellas, tuve que crear otro proyecto móvil (el que usa lo definido en Proyecto2), pero para no repetir todo el código que ya tengo hecho, añadí una referencia a Proyecto1 en el Proyecto2.

Y lo curioso es que aunque las clases definidas en Proyecto1 se supone que utiliza los recursos que haya en el App.xaml del Proyecto1, al ejecutar la aplicación (que usa Proyecto2) me da error de que no encuentra los recursos, por tanto, tuve que copiar todas las definiciones del fichero App.xaml del Proyecto1 en el App.xaml del Proyecto2.

Hasta aquí todo bien, sin problemas. ¿No?

Pero ahora decido añadir un nuevo estilo o cambiar alguno de los que hay… ¿Qué tengo que hacer? Pues muy fácil: MODIFICAR ambos ficheros App.xaml con esos estilos modificados.

Y la verdad es que para un despistao como yo, eso es unproblema, ya que me puedo tirar un buen rato comprobando porqué no funciona con los nuevos estilos definidos… Hasta caer en la cuenta de que no están definidos en los dos ficheros.
Sí, así de torpe es elGuille 😉

¿Solución? Crear un fichero en el que estén todos los recursos y ese fichero usarlo en los dos proyectos. Y eso es lo que he hecho y como he visto que en la rede de redes no está explicado cómo hacer esto, seguramente porque es algo trivial o fácil, pero la cuestión es que para mí no era tan trivial ni fácil, y como no encontraba la solución… me puse a probar con lo que ya había encontrado y… ahora ya lo tengo claro y para que tú también lo tengas claro, si es que necesitas hacerlo, aquí te lo explico.

En realidad la solución es fácil, lo que me traía de cabeza es que usando esas definiciones con esto: Application.Current.Resources["estilo"], no me funciona (y eso aún no lo he solucionado), así que, tuve que usar lo que te he comentado antes de aplicar los estilos que están en una declaración ResourceDictionary (Acceder desde código a las definiciones de ResourceDictionary), es decir, usando esto: Control.SetDynamicResource(TipoControl.StyleProperty, "estilo"), ya que al fin y al cabo, esos recursos definidos en otro fichero en realidad están definidos como ResourceDictionary.

Vamos con los ejemplos de código, empezando por el código XAML a usar en App.xaml:

<Application.Resources>
    <ResourceDictionary Source="ResourceDictionaryElGuille.xaml"/>

Es decir, se hace de la misma forma que para añadirlo a una página normal.
En este caso no indico ningún path en Source porque ese fichero de recursos está en el mimo directorio que App.xaml.

Si ves el código fuente en GitHub (es el mismo proyecto que los ejemplos de los Trucos para Xamarin.Forms y .NET MAUI en dispositivos) comprobarás que en App.xaml he dejado ese código anterior (el de usar un ResourceDictionary definido en otro fichero) además de otras definiciones que también están en bloques ResourceDictionary.

 

A tener en cuenta

Lo que sí debes tener en cuenta es que si todo lo defines en bloques de ResourceDictionary no podrás acceder a esas definiciones por código usando Application.Current.Resources[«key»].

Es decir, el código usado en el primer ejemplo fallará si esos dos recursos (ColorAzul y ColorRojo) no están directamente definidos en los recursos de la aplicación.

Pero puedes tenerlos definidos en dos sitios diferentes sin conflictos.

Para que todos estos ejemplos funcionen he definido esos dos valores tanto en Application.Resources como en el ResourceDictionary del fichero ese externo.

Por tanto, el código XAML de App.xaml empezaría de esta forma: (sigue con otras definiciones de ResourceDictionary, una que estaba ya en ese fichero cuando se creé el proyecto y los que he definido para usar los colores Color2Azul y Color2Rojo del segundo ejemplo que te mostré antes).
También he definido los recursos ColorAzul y ColorRojo para que el primer ejemplo no de error. Y sí, esas mismas claves están definidas en ambos ficheros, y sin conflictos. 😉

<Application.Resources>
    <ResourceDictionary Source="ResourceDictionaryElGuille.xaml"/>

    <ResourceDictionary>
        <Color x:Key="Color2Azul">#0073cf</Color>
        <Color x:Key="Color2Rojo">Firebrick</Color>
    </ResourceDictionary>

Como ya te he explicado antes, la forma de usar esos valores definidos en un ResourceDictionary es usando el código del segundo ejemplo de este post.

 

Y esto es todo… espero que te haya sido de utilidad.

El código fuente de estos ejemplos (y los del 2 de junio) están en GitHub: ElGuille-Ejemplos.

 

Nos vemos.
Guillermo

Instalando los proyectos de VS2019 v16.11 Preview 1 para .NET MAUI Preview 4

Pues eso… que he instalado el Visual Studio 2019 versión 16.11 Preview 1 para poder usar los proyectos de .NET MAUI Preview 4 y como no había tipos de proyectos para .NET MAUI, y lo que se indica en esa página para tenerlos no es completo, he tenido que buscar en la WEB cómo hacerlo y aquí te pongo unas capturas de ese proceso de configuración de .NET MAUI para poder tener los tipos de proyectos en Visual Studio 2019 v11 Preview 1.

Lo primero es decirte que al PowerShell deberían cambiarle las combinaciones de colores, porque lo que es un servidor, no me resulta fácil ver algunos de los avisos y comandos/opciones… así que… si tampoco puedes verlos en las capturas… imagina lo que pone… 😀

De todas formas te resumo los pasos:

Tienes que abrir una ventana de comandos o PowerShell y escribir:
dotnet tool install -g redth.net.maui.check
A continuación (esto es lo que no vi en la página del anuncio de .NET MAUI Preview 4, aunque ahora releyéndola si lo he visto) escribir:
maui-check
Aunque antes de esto deberías escibir estos dos comandos:
primero:
dotnet new nugetconfig
y después:
dotnet nuget add source -n maui-preview https://aka.ms/maui-preview/index.json
O al menos así lo hice yo, aunque creo que primero escribí el primero el de dotnet tool install
En cualquier caso, si ya lo has hecho, no habrá problemas, tal como verás en las siguientes capturas, ya que te dirá que ya está hecho 😉

Figura 1. No me muestran los proyectos de .NET MAUI.
Figura 2. Ahí dice que ya lo he instalado… pero yo no veo ese texto… tuve que copiarlo para verlo…
Figura 3. Crear la configuración de NuGet y añadirla… aunque ya lo hice según ahí me indica
Figura 4. La comprobación de si está instalado lo necesario para usar .NET MAUI (tuve que «fix» todo eso…).
Figura 5. Y paciencia mientras instala los SDKs, emuladores, etc.
Figura 6. Paciencia mientras sigue instalando…
Figura 7. Hasta que termine de comprobar e instalar.
Figura 8. Ahora si hay proyectos para .NET MAUI en Visual Studio 2019 v11 Preview 1

Por supuesto, estos pasos no habrá que hacerlos una vez que tanto el .NET MAUI como el Visual Studio 2019 (o 2022) que lo soporte estén más actualizados. O eso espero, si no… pues eso… ¡será un rollo!

Y si quieres saber qué se irá incluyendo en las próximas preview de .NET MAUI, aquí tienes el roadmap mostrado cuando sacaron la preview 4.

No he tenido oportunidad de probarlo, he creado un proyecto nuevo, pero la máquina virtual que tengo parece que falla mucho o es que el Visual Studio 2019 versión 16.11 Preview 1 hace que falle, no lo sé… no tengo la paciencia para averiguarlo, entre otras cosas porque esa máquina virtual (en Hyper-V) va lenta y me ralentiza mi equipo, al menos con las cosas que tengo abiertas y que por ahora son más urgentes que probar el .NET MAUI, pero lo probaré… y cuando lo haga, lo sabrás… si sigues lo que publico aquí en el blog o en mi feis, así que… te invito a que entres en la página de elGuille ne el feis: elGuille.info en Facebook.

Espero que te sea de utilidad… ya sabes que esa es siempre la intención. 😉

Nos vemos.
Guillermo

Soluciones a los ejercicios de Trucos para Xamarin.Forms y .NET MAUI en dispositivos

Pues eso… aquí tienes los ejercicios y las soluciones propuestos en el post Trucos para Xamarin.Forms y .NET MAUI en dispositivos. También los tienes disponibles en GitHub.

Los ejercicios eran:

Si quieres, como ejercicio de práctica, puedes hacer lo siguiente:

Ejercicio 1:

Añade un panel (StackLayout) con la orientación horizontal, de esa forma los controles que metas dentro de ese stack se mostrarán uno al lado del otro, pon un Switch seguido de un botón con el texto «Un Switch» y después otro Switch y otro botón con el texto «Otro Switch» (o lo que te de la gana pero que no sea demasiado largo).
En este caso el texto no pillará todo el ancho y verás que no se ve igual en iOS / iPhone que en Android o UWP/Windows.
Si no puedes probarlos en distintos dispositivos emuladores, te pondré la respuesta con algunas capturas de los tres sistemas que utilizo con Xamarin.Forms.

Nota:
Probando el ejercicio, compruebo que el poner más espacios al final, no tienen el efecto deseado, así que… si es iOS usa el valor 6,0 para la propiedad Padding.

Otra cosa interesante que puedes hacer (ejercicio 2) es que las etiquetas estén alineadas en el centro vertical, es decir, para que no se vean con el texto tan arriba, sino en el centro de la propia etiqueta.

Estas son las soluciones

Al ejercicio 1 y 2:

<StackLayout Orientation="Horizontal" Padding="4" Spacing="3">
    <Label Text="2 Switch con botones: " VerticalOptions="Center"/>
    <Switch />
    <!-- Los espacios detrás no se respetan... habrá que usar padding -->
    <Button Text=" Un Switch "
            Padding="{OnPlatform iOS='6,0', Android='6,0', Default=4}"/>
    <Switch />
    <Button Text=" Otro Switch "
            Padding="{OnPlatform iOS='6,0', Android='6,0', Default=4}"/>
</StackLayout>

Nota:
El valor ColorAzul2 está definido en App.xaml.

En ej ejercicio 2 lo que debes usar es: VerticalOptions="Center"

Capturas de los ejemplos

Aquí te dejo algunas capturas (me gusta que los posts tengan imágenes 😉 )

Ya sabes, pulsa en la imagen para verla en grande.

Figura 1. Página principal del proyecto en Android.

Figura 2. La solución a los ejercicios en Android.

Figura 3. Página principal del proyecto en iPhone.

Figura 4. Las soluciones en iPhone, pero en modo oscuro no se ve la etiqueta…

Figura 5. Solución a los ejercicios en iPhone (usando el tema claro).

Y esto es todo.

Lee el post de estos ejercicios porque hay cambios.

Nos vemos.
Guillermo

Trucos para Xamarin.Forms y .NET MAUI en dispositivos

Pues eso… te voy a relacionar varios trucos sobre cómo usar el código (y el código de marcado XAML) para dispositivos móviles (Android, iOS y UWP -Windows 10-) usando Xamarin.Forms (Mono mobile) y seguramente servirá para .NET MAUI, la que será el sustituto de Xamarin cuando .NET 6.0 esté en fase release (sobre noviembre de este año 2021).

Nota:
El código mostrado a la hora de escribir este post (2 de junio de 2021 a las 11:15) es para Xamarin.Forms y C#.
Cuando tenga ejemplos de .NET MAUI lo indicaré si es diferente al de Xamarin.

Los trucos

El código con los ejemplos, ejercicios y soluciones están publicados en GitHub.

  1. Saber la plataforma (Android, iOS o UWP) y el tipo de dispositivo (Phone, Tablet, TV, Watch, Desktop)
  2. Poner varios valores en el código XAML usando OnPlatform, OnIdiom, etc.
    1. Ejercicio 1
    2. Ejercicio 2
  3. Si al crear un proyecto no te aparecen los emuladores ni dispositivos
  4. Acceder a los recursos definidos en ResourceDictionary o Application.Resources desde código (C#) (en otro post del 14-jun-2021)

Saber la plataforma (Android, iOS o UWP) y el tipo de dispositivo (Phone, Tablet, TV, Watch, Desktop)

Algunas veces es conveniente saber si la aplicación está funcionando en un dispositivo Android, iOS o compatible con UWP (Windows 10 escritorio o móvil, Xbox, etc.), tanbién si es un móvil, escritorio, tablet, etc.

La primera (la plataforma) se averigua con Platform y OnPlatform y los valores aceptados son los indicados en la tabla 1 (de la ayuda de Xamarin.Forms) que corresponden al tipo DevicePlatform:

La segunda (el tipo de dispositivo) se averigua con Idiom y OnIdiom y los valores de DeviceIdiom que son los que te muestro en la tabla 2.

Cuando usamos Platform o Idiom lo haremos por código usando la clase DeviceInfo (definida en Xamarin.Essentials).
OnPlatform y OnIdiom lo usaremos en el código XAML.
Ahora veremos ejemplos de código c# y XAML de estos dos casos.

AndroidGets the Android platform.
iOSGets the iOS platform.
macOSMac OS
TizenGets the Tizen platform
tvOSGets the tvOS platform
UnknownGets the unknown platform.
UWPGets the UWP platform.
watchOSGets the watchOS platform
Tabla 1. Valores de la estructura DevicePlatform.

DesktopGets the desktop idiom.
PhoneGets the phone idiom.
TabletGets the tablet idiom.
TVGets the TV idiom.
UnknownGets the unknown idiom.
WatchGets the watch idiom.
Tabla 2. Valores de la estructura DeviceIdiom.

Código de ejemplo

Por código podemos usar DeviceInfo (habrá que importar el espacio de nombres Xamarin.Essentials) y las estructuras DevicePatform o DeviceIdiom según lo que queramos averiguar.

Nota:
En estos ejemplos estoy usando una página sencilla de tipo ContentPage de Xamarin.
En la que estarán definidos los controles usados en el código.

Por ejemplo, si queremos saber si el código está ejecutándose en un dispositivo UWP (por ejemplo, en Windows 10) o en Andoid o en iOS podemos hacer lo siguiente comprobando la propiedad Platform del tipo DeviceInfo:

// Saber la plataforma
if (DeviceInfo.Platform == DevicePlatform.UWP)
    LabelDevicePlatform.Text = "Estás usando la plataforma UWP";
else if (DeviceInfo.Platform == DevicePlatform.Android)
    LabelDevicePlatform.Text = "Estás usando la plataforma Android";
else if (DeviceInfo.Platform == DevicePlatform.iOS)
    LabelDevicePlatform.Text = "Estás usando la plataforma iOS";

Lo mismo te interesa saber si se está ejecutando en un teléfono móvil una tableta o en el escritorio, para eso usaremos la propiedad Idiom de la clase DeviceInfo:

// Saber el tipo de dispositivo
if (DeviceInfo.Idiom == DeviceIdiom.Desktop)
    LabelDeviceIdiom.Text = "Estás usando el escitorio.";
else if (DeviceInfo.Idiom == DeviceIdiom.Phone)
    LabelDeviceIdiom.Text = "Estás usando un teléfono móvil.";
else if (DeviceInfo.Idiom == DeviceIdiom.Tablet)
    LabelDeviceIdiom.Text = "Estás usando una tableta.";

Pero puede ser que lo que queremos es asignar un color según el código esté funcionando en una de las plataformas. En lugar de hacerlo por código, lo podemos hacer definiendo esa característica en el diseñador XAML.

Vamos a verlo aplicando un color al fondo de la etiqueta LabelDevicePlatform definida en el ejemplo.

<Label x:Name="LabelDevicePlatform" Padding="6"
       TextColor="White"
       BackgroundColor="{OnPlatform Android=#FA3F7E, iOS=#34C759, UWP=#0077DF}" />

En el código XAML es donde usaremos OnPlatform.

De igual forma podemos usar OnIdiom para saber el tipo de dispositivo.

<Label x:Name="LabelDeviceIdiom" Padding="6" 
       TextColor="{OnPlatform Android=Black, iOS=Blue, UWP=Green}"
       BackgroundColor="Wheat"
       FontSize="{OnIdiom Tablet=Small, Phone=Micro, Desktop=Medium}"/>

En ese código XAML hacemos las dos comprobaciones, la plataforma y el dispositivo y según sea aplicaremos un color u otro.

Si quieres hacer solo esa comprobación, por ejemplo para que en dispositivos de Apple (iOS) tengan un color y que en el resto tenga otro, podemos hacerlo de esta forma:

<Label Text="DeviceIdiom: " TextColor="{OnPlatform iOS=Green, Default=Red}"/>

En ese caso usamos el valor (o propiedad) Default que se aplicará a las plataformas (o dispositivos si se usa con OnIdiom) para las que no haya un valor concreto.

Poner varios valores en el código XAML usando OnPlatform, OnIdiom, etc.

Otra de las cosas que me ha pasado mientras estoy con esto de crear aplicaciones para dispositivos móviles y concretamente con el iPhone (iOS), en el que el texto mostrado en uno de los tipos de botones que estoy usando (para simular un Switch) es que el texto se queda pegado a los bordes del botón, mientras que en Android y UWP se quedaba separado.

Para solucionarlo necesitaba hacer dos cosas:
1- La más simple es poder añadir espacios delante y detrás del texto. Esto sería fácil si esa asignación la hago por código (c#), pero yo quería hacerla en el código de diseño (XAML).
2- Cambiar el Padding izquierdo y derecho.

El problema es que para el primer caso, tenía que asignar espacios delante y detrás del texto, pero ni usando el valor 255 (ALT+255) lo conseguí, ya que al ejecutar el código esos espacios se ignoran .

En el segundo caso, es que al asignar valores separados por comas da error, ya que después de cada coma se espera una propiedad.

Por ejemplo, lo del espacio.
Fíjate en el siguiente código XAML el valor del texto (propiedad Text) lo asigno usando un valor diferente según la plataforma.
Si es iOS uso un espacio delante y detrás de la palabra ATRÁS, en el resto de plataformas (Default) use ese mismo texto pero sin espacios:

<Button x:Name="btnAtras" 
        Text="{OnPlatform iOS= ATRÁS , Default=ATRÁS}" 
        HorizontalOptions="FillAndExpand"
        Style="{StaticResource BtnNavegar}"
        Clicked="btnAtras_Clicked"/>

Y si ese texto llevase comas, pues… ni se podría poner.

Ese sería el caso para cuando queremos asignar un valor que tenga varios argumentos separados por comas, como es el caso de Padding si no queremos asignar un solo valor para los 4 costados. Ya que solo me interesaba para la parte iaquierda y derecha, que si lo asignase de forma normal sería algo así:

Padding="6,0"

El primer valor se asignará a la izquierda y derecha (Left y Right) y el segundo valor arriba y abajo (Top y Botton).
Que queremos asignar 4 valores diferentes, lo haremos así:

Margin="4,5,6,7"

Los valores serían: 4 para la izquierda, 5 para arriba, 6 para la derecha y 7 para abajo.

La solución: Poner el texto entre comillas simples (las dobles no se pueden usar, ni siquiera usando teclas de ESCAPE, algo así: \»).

Por cierto, esa solución también es válida para el código HTML, cuando quieres poner comillas dentro de unas comillas, por ejemplo un valor style en el texto asignado a algo mediante código. Pero esa es otra historia.

Dicho lo dicho, la cosa quedaría de esta forma, si lo que se busca es que el padding izquierdo y derecho sea 6 para la plataforma iOS y 0 para el resto y que el texto incluya comas o espacios delante y/o detrás, si esos espacios están entro otros caracteres no hay que hacer nada especial.

<Label x:Name="LabelStatus" Style="{StaticResource LabelStatusWiz}"
       Padding="{OnPlatform iOS='6,0', Default=0}"
       Text="{OnPlatform Android=' Dispositivo \'Android\' ', 
                         iOS=' Dispositivo iPhone (\'iOS\') ', 
                         UWP='Dispositivo UWP (\'Windows 10, XBox\')'}"/>

Como ves el valor del Padding para iOS es ‘6,0’ (entre comillas simples).
Fíjate también que en ese código (para el valor de la propiedad Text) he usado \’ para indicar que quiero usar una comilla simple, esto solo funcionará si el texto completo está encerrado entre comillas simples.

Aquí tienes unas capturas de UWP: Windows 10 en el equipo local o lo que es lo mismo, usando el escritorio (figura 1), para Android (figura 2) y para iOS en un iPhone 7 Plus (figuras 3 y 4).

Observa los colores de las etiquetas (fondo y texto), así como en la parte de abajo que hay texto entre comillas simples.

Y observa que el padding para el botón ese con el texto tan largo, pues como que no sirve de mucho, ya que el botón pilla todo el ancho de la pantalla, pero sería útil si ese botón se está mostrando en un sitio que no lo expanda.

Si quieres, como ejercicio de práctica, puedes hacer lo siguiente:

Ejercicio 1:

Añade un panel (StackLayout) con la orientación horizontal, de esa forma los controles que metas dentro de ese stack se mostrarán uno al lado del otro, pon un Switch seguido de un botón con el texto «Un Switch» y después otro Switch y otro botón con el texto «Otro Switch» (o lo que te de la gana pero que no sea demasiado largo).
En este caso el texto no pillará todo el ancho y verás que no se ve igual en iOS / iPhone que en Android o UWP/Windows.
Si no puedes probarlos en distintos dispositivos emuladores, te pondré la respuesta con algunas capturas de los tres sistemas que utilizo con Xamarin.Forms.

Nota:
Probando el ejercicio, compruebo que el poner más espacios al final, no tienen el efecto deseado, así que… si es iOS usa el valor 6,0 para la propiedad Padding.

Otra cosa interesante que puedes hacer (ejercicio 2) es que las etiquetas estén alineadas en el centro vertical, es decir, para que no se vean con el texto tan arriba, sino en el centro de la propia etiqueta.

Pulsa en las imágenes para verlas a tamaño real.

Figura 1. El ejemplo en un Windows 10 (UWP).

Figura 2. El ejemplo en un móvil de Android (Pixel 4a).

Figura 3. El ejemplo en un móvil iOS (iPhone 7 Plus). Observa que no se ve todo el texto.

Figura 4. El ejemplo en un móvil iOS (iPhone 7 Plus).

Si miras las capturas 3 y 4 verás que en la última ya se ve bien el texto, tanto de la etiqueta de arriba como en la que tiene el fondo verde (la que indica que estás usando la plataforma iOS), para solucionar esa error, he vuelto a usar lo comentado en este post.

En el caso de la etiqueta de Xamarin he ajustado el valor de Padding para el iOS que sea más pequeño que para el resto.

<Label Text="Welcome to Xamarin.Forms!" FontSize="Title" 
       BackgroundColor="#96d1ff" Padding="{OnPlatform iOS=10,Default=40}"
       VerticalOptions="CenterAndExpand" 
       HorizontalOptions="CenterAndExpand" />

Para la etiqueta donde se muestra la plataforma en la que se está usando la aplicación, he optado por cambiar el tamaño de la letra.

<Label x:Name="LabelDevicePlatform" Padding="6"
       FontSize="{OnPlatform iOS=Micro, Default=Small}"
       TextColor="White"
       BackgroundColor="{OnPlatform Android=#FA3F7E, iOS=#34C759, UWP=#0077DF}" />

Nota importante sobre los valores asignados cuando usamos OnPlatform, OnIdiom, etc.
Cuando usamos, por ejemplo, OnPlatform el Intellisense de Visual Studio (en este ejemplo estoy usando Microsoft Visual Studio Community 2019 Version 16.10.0) te muestra los valores de la plataforma (iOS, Android, UWP, Default, etc.), pero no te muestra el intellisense para los valores asignados.
Por ejemplo, en el valor de FontSize del código XAML anterior, he usado el valor Micro para iOS y Small para el resto (Default), esos valores hay que ponerlos como se deben poner, me explico: si el valor es Micro con la m mayúscula, debe estar así escrito, si pones micro (con la m en minúscula) te dará error… Esto lo sé porque lo escribí en minúscula y al ejecutar el programa en el iPhone me dijo que nones… 😉

Si al crear un proyecto no te aparecen los emuladores ni dispositivos

Pues eso… he creado un nuevo proyecto para Xamarin.Forms para estos ejemplos y ejercicios y al intentar probarlo en otra plataforma distinta a UWP, vamos al intentar probarlo en Android o iPhone no me salían las opciones de los emuladores o los dispositivos.

¿La solución?
Cerrar la solución y volverla a abrir, así de simple.

En la página de las soluciones a los ejercicios tienes las capturas del proyecto que he creado y que está publicado en GitHub (aquí más abajo tienes el enlace).

Y esto es todo.

Solo falta publicar el proyecto en GitHub, pero como lo he usado en la aplicación que tengo para las reservas de MKN (la empresa donde trabajo), tendré que crear un proyecto/solución para poder ponerlo en GitHub y así poder descargarlo, etc.
Ya avisaré. Avisado estás de que ya está publicado en GitHub 😉
La solución a los dos ejercicios las pondré en otro post y también estarán en GitHub.

El código en GitHub

elGuille-Ejemplos

Nos vemos.
Guillermo

Tutorial Google APIs – Código para acceder a los contactos con People API

Ya estás en la segunda entrega de este Tutorial sobre el uso de las APIs de Google.
Aquí te mostraré el código de Visual Basic y C# para acceder a los contactos de Google usando People API. Como te comenté en la priumera entrega sobre cómo crear un proyecto en Google Cloud, el API que usaremos es People API, no te confundas con Contacts API (como a mí me ocurrió) ya que parece que será la más adecuada, pero además de que Google no recomienda que se use Contacts API, la he probado y no he conseguido sacar prácticamente nada de información, y al que he sacado es de unos pocos contactos (que ni recordaba que los tenía creados).

Nota:
Está uno acostumbrado a que te marquen los errores horrográficos que esto de que no te los marque es un Orror! 😛

Bueno vamos empezar con el código de C# que es lo que la gente suele ver en internet (de VB no he visto ni un ejemplo, así que… ya mismo lo verás en primicia).

Después de escribir el párrafo anterior he cambiado de opinión y te voy a enseñar conjuntamente el código de los dos lenguajes, para que vayas comparando.

Código de C# y VB para mostrar los contactos de una cuenta de Google usando People API

Nota:
Debo decir que parte de este código lo he visto en algunos ejemplosencontrados tanto en la documentación de Google como en foros de C#. Pero principalmente de la documentación (escasa) de Google y en agunos casos, los ejemplos eran de java, ni siquiera de C#.

Como te comenté en el preámbulo del tutorial, debes añadir las referencias a los paquetes de NuGet que instalarán las APIs en tu proyecto. Yo he añadido todas las que te indiqué en esa primera página del tutorial. Por supuesto si quieres acceder, por ejemplo al calendario o a GMail, tendrás que añadir referencias a esas APIs, además de añadirlas al proyecto creado en Google Cloud Platform.

Veamos el código inicial (con las importaciones de los espacios de nombres) que será básicamente el mismo en todas las apliocaciones que hagas para acceder a las APIs de Google.

// Genéricas
using Google.Apis.Auth.OAuth2;
using Google.Apis.Services;
using Google.Apis.Util.Store;
// People API
using Google.Apis.People.v1;
using Google.Apis.People.v1.Data;
// Docs API
using Google.Apis.Docs.v1;
using Google.Apis.Docs.v1.Data;
// Drive API
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data; // Para el tipo File

using System;
using System.Collections.Generic;
//using System.IO;
using System.Threading;
using System.Text;
using System.Linq;
'// Genéricas
Imports Google.Apis.Auth.OAuth2
Imports Google.Apis.Services
Imports Google.Apis.Util.Store
'// People API
Imports Google.Apis.People.v1
Imports Google.Apis.People.v1.Data
'// Docs API
Imports Google.Apis.Docs.v1
Imports Google.Apis.Docs.v1.Data
'// Drive API
Imports Google.Apis.Drive.v3
Imports Google.Apis.Drive.v3.Data '// Para el tipo File

Imports System
Imports System.Collections.Generic
Imports System.Threading
Imports System.Text
Imports System.Linq

Ahora vamos a crear una serie de campos estáticos/compartidos (static en C#, shared en VB) que usaremos también de forma genérica en todos los proyectos de acceso a Google APIs.

class Program
{
    // If modifying these scopes, delete your previously saved credentials
    // at ~/.credentials/docs.googleapis.com-dotnet-quickstart.json
    static string[] Scopes = { DocsService.Scope.Documents, 
                               DocsService.Scope.DriveFile, 
                               PeopleService.Scope.ContactsReadonly };

    static string ApplicationName = "Tutorial Google APIs VB";

    // Los datos del proyecto creado para VB
    static ClientSecrets secrets = new ClientSecrets()
    {
        ClientId = "430211665266-t68vl99t2q40v3lbctgbph23j2644bpj.apps.googleusercontent.com",
        ClientSecret = "Xqexl0FMPedNc1KYs0iJt22A"
    };

    static DocsService docService;
    static DriveService driveService;
    static PeopleService peopleService;

    static UserCredential Credential;
Class Program

    Shared Scopes As String() =
        {
            DocsService.Scope.Documents,
            DocsService.Scope.DriveFile,
            PeopleService.Scope.ContactsReadonly
        }

    Shared ApplicationName As String = "Tutorial Google APIs VB"

    Shared secrets As ClientSecrets = New ClientSecrets() With
        {
            .ClientId = "430211665266-t68vl99t2q40v3lbctgbph23j2644bpj.apps.googleusercontent.com",
            .ClientSecret = "Xqexl0FMPedNc1KYs0iJt22A"
        }

    Shared docService As DocsService
    Shared driveService As DriveService
    Shared peopleService As PeopleService

    Shared Credential As UserCredential

Lo que ese primer comentario indica (es de un quickstart de Google) es que si cambias los valores del array Scopes debes eliminar el directorio creado en Documentos\.credentials (ahora verás porqué).

El array Scopes contiene los ámbitos de la aplicación, es a qué estamos pidiendo permiso para acceder. Ahí he añadido los tres ámbitos que usaré en este tutorial, pero si solo quieres acceder a los contactos con People API, añadiendo PeopleService.Scope.ContactsReadonly sería suficiente. Si te fijas, estás pidiendo autorización (a OAuth) para acceder de forma de solo lectura a los contactos.
En realidad estás pidiendo permisos para acceder a los Documentos y al Drive sin restricciones, pero a los contactos solo para leerlos. Estos dos últimos necesitan más permisos porque queremos crear ficheros, eliminarlos, lo mismo con los documentos.

Lo importante (también) es la asignación de ClientSecrets, ahí tendás que poner los datos que te haya generado al configurar el OAuth de la aplicación. Eso que te muestro son los valores que en mi proyecto para este tutorial he pedido, el que se indique que la aplicación se llama Tutorial Google APis VB no significa que no se pueda usar para C#, ese título o nombre de aplicación no es restrictivo para nada.

Nota:
Normalmente esos valores se recomienda que no se hagan públicos… ¡vaya el caso que hago! jejejeje… pero para este caso, me fio de ti, y sé que no se lo dirás a nadie y así lo mantenemos en secreto… 😉

Las tres declaraciones después de asignar el valor a secrets son para acceder a los servicios de las tres APIs que usaré en estos tutoriales, las defino a nivel de clase para que se puedan usar en todos los métodos que sean necesarios y no tener que pasarlas como argumento de llamada al método que lo necesite.

La última declaración (Credential) es para crear las credenciales del usuario. La asignación la haré en el método Main, y como es un valor compartido, también se podrá usar en cualquier parte de la clase.

El siguiente código es el método Main, en el que llamaremos al método que accede a los contactos y los muestra.

Y como verás en las capturas el correo que he usado no tenía ningún contacto y he tenido que crear uno para comprobar que funciona… las cosas del Guille…

static void Main(string[] args)
{
    Console.WriteLine("Tutorial Google APIs con C#");

    string credPath = System.Environment.GetFolderPath(
        Environment.SpecialFolder.Personal);
    
    // Directorio donde se guardarán las credenciales
    credPath = System.IO.Path.Combine(credPath, ".credentials/Tutorial-Google-APIs-VB");

    Credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
        secrets,
        Scopes,
        "user",
        CancellationToken.None,
        new FileDataStore(credPath, true)).Result;
    //Console.WriteLine("Credential file saved to: " + credPath);

    // Mostrar los contactos
    MostrarContactos();

    Console.WriteLine();
    Console.WriteLine("Pulsa una tecla.");
    Console.Read();
}
Public Shared Sub Main(ByVal args As String())

    Console.WriteLine("Tutorial Google APIs con Visual Basic")

    Dim credPath As String = System.Environment.GetFolderPath(
        Environment.SpecialFolder.Personal)

    '// Directorio donde se guardarán las credenciales
    credPath = System.IO.Path.Combine(credPath, ".credentials/Tutorial-Google-APIs-VB")

    Credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
        secrets,
        Scopes,
        "user",
        CancellationToken.None,
        New FileDataStore(credPath, True)).Result

    '// Mostrar los contactos
    MostrarContactos()

    Console.WriteLine()
    Console.WriteLine("Pulsa una tecla.")
    Console.Read()
End Sub

El valor de credPath es el direcorio donde se crearán las credenciales que vamos a usar en este programa. Se guardará en los documentos del usuario en una carpeta llamada Tutorial-Google-APIs-VB que estará incluida en .credentials.

Si haces cambios en los permisos o te han faltado permisos en la configuración de OAuth y los modificas, debes eliminar la carpeta del tutorial, a de .credentials la puedes dejar, por si la usas para almacenar las credenciales de otros programas que use el usuario.
También tendrás que borrarla si decides usar otra cuenta de Google (GMail) para acceder a esos contactos. Si solo tienes una cuenta de GMail, no hará falta que la borres salvo para los dos primeros casos.

Cuando ejecutemos la aplicación verás qué es lo que se guarda en esa carpeta.

A Credentials le asignamos las credenciales que queremos usar.

Aquí tengo que hacer una puntuialización.
El valor de secrets se asigna con los valores que hemos indicado (de foirma llana y clara) antes, pero también se puede hacer accediendo a un fichero que contiene esos valores, al menos así no se mostrarán directamente en el código los valores secretos. Aunque seguirán estando al alcance del usuario de la aplicación.

La forma de hacerlo lo pondré en otro ejemplo de este tutorial.

Ahora solo nos falta ver qué código contiene elmétodo MostrarContactos.

¡Vamos a ello!

private static void MostrarContactos()
{
    // Create Drive API service.
    peopleService = new PeopleService(new BaseClientService.Initializer()
    {
        HttpClientInitializer = Credential,
        ApplicationName = ApplicationName,
    });

    // Lista de los contactos (People)
    Console.WriteLine("Contactos:");

    // Este muestra todos los contactos
    GetPeople(peopleService, null);

    Console.WriteLine();
    Console.WriteLine($"Hay {total} contactos / People");
    Console.WriteLine();
}
Private Shared Sub MostrarContactos()
    peopleService = New PeopleService(New BaseClientService.Initializer() With
    {
        .HttpClientInitializer = Credential,
        .ApplicationName = ApplicationName
    })

    Console.WriteLine("Contactos:")

    GetPeople(peopleService, Nothing)

    Console.WriteLine()
    Console.WriteLine($"Hay {total} contactos / People")
    Console.WriteLine()
End Sub

Le asignamos el valor a peopleService para que pida esos permisos a Google, como ves se usa el protocolo HTTP.
Eso lo que hará es abrir una página en el navegador pidiendo permiso para acceder a los datos de una cuenta de GMail (ver la figura 1)

Figura 1. Seleccionar la cunta que queremos usar para acceder a sus contactos.

Esa primera pantalla nos pide que indiquemos a qué contactos queremos acceder, es decir, solo accederá a los contactos de la cuenta que indiques, y para indicar esa cuenta debes tener el password, si no… no hay nada que hacer.
Por tanto, esto que vamos a hacer es seguro, en el sentido de que yo no voy a acceder (ni puedo) a tus contactos… otra cosa es que mi aplicación se comunicara conmigo o guardara esa información en algún sitio… pero no te preocupes, no lo hace, además lo puedes comprobar por ti mismo viendo el código.

Una vez elegida la cuenta, te mostrará un aviso de que la aplicación no es segura o, en realidad, que no se ha verificado (ver la figura 2).
Tendrás que autorizarla para que pueda seguir.

Figura 2. DEbes mostrar la información oculta para permitir ir a la aplicación

Una vez hechoi esto, Google te pedirá confirmación para dejar que la aplicación haga lo que se ha indicado en Scopes. Así que… otras tres pantallitas más de autorización (ver figuras 3 a 5).

Figura 3. Permiso para ver los contactos.
Figura 4. Acceder al Drive.
Figura 5. Acceder a los documentos.

Y una vez permitido estas cosas, debes terminar de aceptarlo (ver la figura 6 en la está el resumen de los permisos que le darás a la aplicación).

Figura 6. Confirmación final de los permisos.

Después de pulsar en Permitir, el navegador te mostrará un mensaje de que puedes cerrar la página.

Estos permisos no te los volverá a pedir para usar esta aplicación. Y por tanto, siempre accederá a la cuenta de GMail que has indicado.

Si quieres usar otra cuenta diferente, borra la carpeta esa que te comenté antes (o el fichero que contiene) y eso hará que te vuelva a mostrar todas estas pantallas.

Antes de seguir, espera un poco que me estoy meando de la risa… ¡ay!

Es que te dije que definí la variable peopleService (y las otras dos) a nivel de clase para no tener que usarla como argumento a un método y voy y pongo como argumento el valor de esa variable compartida… en fin… la cabeza del Guille…

Bueno, ya.

Sigamos con el código que accede a los contactos.

private static int total = 0;

static void GetPeople(PeopleService service, string pageToken)
{
    // Define parameters of request.
    PeopleResource.ConnectionsResource.ListRequest peopleRequest =
            service.People.Connections.List("people/me");

    //
    // Lista de campos a usar en RequestMaskIncludeField:
    // https://developers.google.com/people/api/rest/v1/people/get
    //

    peopleRequest.RequestMaskIncludeField = new List<string>()
            {"person.names", "person.phoneNumbers", "person.emailAddresses",
              "person.birthdays", "person.Addresses"
            };


    if (pageToken != null)
    {
        peopleRequest.PageToken = pageToken;
    }

    ListConnectionsResponse people = peopleRequest.Execute();

    if (people != null && people.Connections != null && people.Connections.Count > 0)
    {
        total += people.Connections.Count;
        foreach (var person in people.Connections)
        {
            Console.Write(person.Names != null ? ($"{person.Names.FirstOrDefault().DisplayName} - ") : "");
            Console.Write(person.PhoneNumbers != null ? ($"{person.PhoneNumbers.FirstOrDefault().Value} - ") : "");
            Console.Write(person.EmailAddresses != null ? ($"{person.EmailAddresses.FirstOrDefault().Value} - ") : "");
            Console.Write(person.Addresses != null ? ($"{person.Addresses.FirstOrDefault()?.City} - ") : "");
            if (person.Birthdays != null)
            {
                var fecha = "";
                var b = person.Birthdays.FirstOrDefault()?.Date;
                if (b != null)
                    fecha = $"{b.Day}/{b.Month}/{b.Year}";
                Console.Write($"{fecha}");
            }
            Console.WriteLine();
        }

        if (people.NextPageToken != null)
        {
            Console.WriteLine();
            Console.WriteLine($"{total} contactos mostrados hasta ahora. Pulsa una tecla para seguir mostrando contactos.");
            Console.WriteLine();
            Console.ReadKey();

            GetPeople(service, people.NextPageToken);
        }
    }
    else
    {
        Console.WriteLine("No se han encontrado contactos.");
        return;
    }
}
Private Shared total As Integer = 0

Private Shared Sub GetPeople(service As PeopleService, pageToken As String)

    Dim peopleRequest As PeopleResource.ConnectionsResource.ListRequest =
        service.People.Connections.List("people/me")

    peopleRequest.RequestMaskIncludeField = New List(Of String)() From {
            "person.names",
            "person.phoneNumbers",
            "person.emailAddresses",
            "person.birthdays",
            "person.Addresses"
        }

    If pageToken IsNot Nothing Then
        peopleRequest.PageToken = pageToken
    End If

    Dim people As ListConnectionsResponse = peopleRequest.Execute()

    If people IsNot Nothing AndAlso
            people.Connections IsNot Nothing AndAlso
            people.Connections.Count > 0 Then
        total += people.Connections.Count

        For Each person In people.Connections
            Console.Write(If(person.Names IsNot Nothing,
                          ($"{person.Names.FirstOrDefault().DisplayName} - "), ""))
            Console.Write(If(person.PhoneNumbers IsNot Nothing,
                          ($"{person.PhoneNumbers.FirstOrDefault().Value} - "), ""))
            Console.Write(If(person.EmailAddresses IsNot Nothing,
                          ($"{person.EmailAddresses.FirstOrDefault().Value} - "), ""))
            Console.Write(If(person.Addresses IsNot Nothing,
                          ($"{person.Addresses.FirstOrDefault()?.City} - "), ""))

            If person.Birthdays IsNot Nothing Then
                Dim fecha = ""
                Dim b = person.Birthdays.FirstOrDefault()?.Date
                If b IsNot Nothing Then fecha = $"{b.Day}/{b.Month}/{b.Year}"
                Console.Write($"{fecha}")
            End If

            Console.WriteLine()
        Next

        If people.NextPageToken IsNot Nothing Then
            Console.WriteLine()
            Console.WriteLine($"{total} contactos mostrados hasta ahora. " &
                              "Pulsa una tecla para seguir mostrando contactos.")
            Console.WriteLine()
            Console.ReadKey()
            GetPeople(service, people.NextPageToken)
        End If
    Else
        Console.WriteLine("No se han encontrado contactos.")
        Return
    End If
End Sub

El valor de peopleRequest debe ser siempre people/me o bien si te sabes el ID de otro usuario lo podrías indicar en lugar de «me«. Ese me significa que accedes a tus contactos.
He buscado por todas partes, y no he averiguado como saber ese famoso ID, ni siquiera de una de mis cuentas para poder saber si se puede acceder a la cuenta de alguien que no seas tú.
Cuando lo averigüe te lo cuento.

Los valores asigndos a la lista RequestMaskIncludeField serán a los datos que queremos acceder y siempre deben empezar con person. seguido del campo al que queremos acceder. En este ejemplo estamos indicando que queremos acceder a: los nombres, teléfonos, emails, cumpleaños y domicilios.

Y como esos valores pueden ser nulos (y normalmente son una colección de valores), comprobamos si es nulo y en el caso de las colecciones accedemos al primero o al predeterminado, si hay algo lo mostramos y si no, se usa una cadena vacía.

Con el valor de Birtdays debemos hacer una comprobación más elaborada e incluso te recomendaría que usaras un try/catch si quieres acceder a los valores de la fecha, porque de las pruebas que he heco, en un caso me dio error al querer acceder al año… se ve que el contacto ese no quería dar su año de nacimiento y dio error al querer convertirlo a entero… en fin…

El NextPageToken nos indica que hay más págins de datos, así que… si las hay volvemos a llamar a este método y seguimos mostrando los contactos que falten por acceder.

Y esto es todo lo que hay que hacer para mostrar los contactos usando People API. Otra cosa es que quieras crear contactos o modificarlos, en esos casos tendrás que modificar el valor del Scope de los contatos.
Si hago pruebas de crear o modificar te los pondré por aquí.

Para terminar, la captura del programa en funcionamiento. Ver la figura 7.

Figura 7. La cuenta que he usado para acceder a los contactos, ¡no tiene contactos!

Pues la sorpresa que me llevé… pensé que lo mismo fallaba algo, así que… me fui a google, creé un contacto y volvía a probar… ¡Esta vez sí que sí! (ver la figira 8).

Figura 8. Un contacto tengo en la cuenta que he usado para esta prueba.

Y esto es todo por ahora.

Ahora a esperar a la siguiente entrega.

Este código está publicado en GitHub: Tutorial-APIs-Google.

Nos vemos.
Guillermo

P.S.
Versión en inglés / English version.

Tutorial Google APIs – Crear Proyecto en Google Cloud

Aquí tienes la primera entrega del tutorial sobre el uso de las APIs de Google para acceder a Drive, Contactos y Documentos.

Si quieres crer una cuenta y un proyecto para poder acceder a esos APIs de Google, lo primero es acceder a Google Cloud Platform y crear una cuenta, o mejor dicho, activarla con Google Cloud.

Una vez que tengas la cuenta, tendrás que crear un proyecto y configurarlo para que pueda acceder a esas APIs.

En este tutorial te explico paso a paso cómo hacerlo, y con un montón de capturas para que no te líes y yo no me olvide de contarte los paso, que todo hay que decirlo. 🙂

Nota:
Por ahora te voy dejar las capturas y en otra ocasión, si hace falta, te explico lo que cada captura significa.
Es que quiero pasar a mostrarte el código para acceder al API de People (contactos) que ya lo tengo hecho tanto con C# como con Visual Basic.

Figura 1. Crear un nuevo proyecto

 

Figura 2.

 

Figura 3.

 

Figura 4.

 

Figura 5.

 

Figura 6. En la ficha G Suite están las de Docs API y drive API

 

Figura 7. Tienes que elegir y habilitar una por una.

 

Figura 8.

 

Figura 9. Añadir más librerías (bibliotecas)

 

Figura 10. Elige People API. No elijas Contacts API, que aparte de estar obsoleta, no vale para nada…

 

Figura 11. Esta es la parte más importnte, sin la autorización OAuth no podrás acceder a nada.

 

Figura 12. Siempre debe ser External

 

Figura 13.

 

Figura 14.

 

Figura 15. Añadir las características que tu aplicación usará de cada API que has añadido.

 

Figura 16.

 

Figura 17.

Nota:
Los permisos debes ir probándolos a ver qué error te da, según lo que quieras hacer.
Pero básicamente necesitas acceso de lectura, salvo que quieras modificar un contacto, un documento o algún fichero del Drive.

Figura 18. No te olvides de darle a UPDATE ya que al estar tan abajo en la pantalla emergente ni se ve, y so no le das a Update, no se guardan los cambios.

 

Figura 19.

 

Figura 20.

 

Figura 21. Aquí tienes que añadir los usuarios autorizados para que usen la aplicación. El máximo es 100 y una vez que aades uno, ya no lo puedes eliminar.

 

Figura 22.

 

Figura 23. Los tipos de credenciales que crearemos

 

Figura 24.

 

Figura 25. Estas so las APIs que usaremos con este proyecto.

 

Figura 26. El tipo de aplicación que vamos a crear.

 

Figura 27.

 

Figura 28. Estas son las dos claves que necesitarás en tu código

 

Figura 29.

 

Figura 30.

 

Figura 31. Si no hs copiado las credenciales de acceso, descarga el fichero .json y ahí las tienes.

 

 

Pues esto es todo lo que debes saber para crear un proyecto.
En la siguiente entrega voy a mostrarte el código de una aplicación de consola para acceder a los contactos (People API). Sí, en C# y en VB.

 

 

Nos vemos.
Guillermo

Tutorial para usar las APIs de Google con C# y Visual Basic

Pues eso… que como yo me he encontrado con problemas a la hora de implementar las APIs de Google y de encontrar ejemplos (que de haberlos solo eran para C#), me he decido a escribir esta especie de tutorial para poder acceder a las siguientes APIs de Google: Drive, Docs y People. Es decir, poder manipular el contenido de Google Drive, los documentos y los contactos de Google que están asociados tu cuenta (o la cuenta que decidas usar) de GMail.

Lo primero que necesitas (salvo que uses las que yo voy a crear para este tutorial) es crearte una cuenta en Google Cloud Platform, es gratuito al menos sino usas recursos que son de pago.
La cuenta a usar será la que tengas ya de GMail o bien puedes crear una nueva cuenta y asociarla con Google Cloud.

Cuandoi asocias una cuenta por primera vez, te darán una oferta de 300$ (US $) para que pruebes de forma gratuita los recursos de pago (siempre que no te pases de esos 300 dólares). Pero como te digo, para las cosas que te voy a explicar no te hace falta.

Por ahora me voy a saltar el paso de crear tus propios poyectos en Google Cloud, eso lo dejaré para el final (salvo que cambie de opinión), lo que sí te digo es que si quieres utilizar los ejemplos que te voy a mostrar usando mis claves o las que yo indique en el código) antes debes decírmelo para poder añadir tu correo de GMail a los usuarios que pueden usar esas claves.

Esto ultimo lo puedes hacer dejando un comentario en este mismo post y yo te agregaré, esto puede que no lo haga pasado unos meses, ya que solo quiero que la gente lo pruebe en este tiempo reciente, mientras publico los tutoriales. Y dejando, como mucho, unos tres meses de desde la publicación original, así que… si estás leyendo este tutorial después del 15 de marzo de 2021, es posible que o bien no admita más usuarios o simplemente que no lo siga «soportando», además de que hay un límite de 100 usuarios por proyecto, y si ya están esos usuarios registrados con la aplciación, es posible que, incluso antes del 15 de marzo del 2021 no pueda admitir más usuarios.

Dicho esto, empecemos.

Nota:
Los ejemplos los voy a hacer con .NET 5.0.1 pero son válidos para .NET Framework v4.5 y superiores, .NET Standard y .NET Core.

Crear un proyecto en C# o Visual Basic

Crea un proyecto de consola para C# o VB y ve a Tools>NuGet Package Manager>Manage NuGet Packages for Solution… (en español es: Herramientas>Administrador de paquetes NuGet>Administrar paquetes NuGet para la solución…)

Busca y añade los siguientes paquetes de NuGet (entre paréntesis te indico las versiones que estoy usando al escribir este tutorial):

Nota:
Los enlaces son por si quieres ir a la página de NuGet y descargarlas desde allí o ver cómo instalarlas según estés usando Visual Studio 2019 o Visual Studio Code o simplemente creando los proyectos desde la consola con dotnet.
Eso sí, necesitarás tener instlado el SDK de dotnet 5 para poder compilar el código.

Esto añadirá las referencias necesarias para usar el código que te mostraré.

Nota:
Si te interesa ver el código fuente de las APIs de google puedes verlas en el siguiente enlace: google-api-dotnet-client.

Las entregas

  1. Entrega 1: Crear Proyecto en Google Cloud
  2. Entrega 2: Código para acceder a los contactos con People API
  3. Entrega 3: Código para acceder a los documentos con Drive API y Docs API
  4. Entrega 4: Código para crear un documento con Docs API

Nota:
Voy a publicar ahora este post mientras creo el protyecto de prueba, escribo el código, lo convierto de C# a VB (ya tengo código escrito en C#) y lo publico, así podrás solicitar tu «permiso» para usar estos ejemplos con mi ID y clave secreta (que después de publicarla no será tan secreta 😉 )

Nos vemos.
Guillermo

Generar clave SHA1 con el nombre y password del usuario

Pues eso… en este post te explico cómo generar una clave (usando la clase SHA1CryptoServiceProvider) formada a partir de dos cadenas, normalmente el nombre del usuario y el password (o contraseña), de esta forma se genera una cadena única (de 40 caracteres) de forma que si alguien accede a ella no sabrá nunca cuales fueron las dos cadenas que la formaron (o eso es lo que espero que ocurra, jejeje). Además te mostraré también una función para evitar que el usuario introduzca caracteres no válidos y que pueden se usados para acceder maliciosamente a una base de datos.
Por supuesto, te mostraré el código tanto para Visual Basic como para C#.

El código que te mostraré (al menos el de generar la clave SHA1) está basado en este código publicado en mi sitio (usando .NET 1.1):
El ejemplo de Visual Basic .NET:
comprobar_usuario_usando_base_datos_vb2003
El ejemplo de C#:
comprobar_usuario_usando_base_datos_cs2003

Generar una clave SHA1 usando SHA1CryptoServiceProvider

Para acceder a esta clase necesitas una importación del espacio de nombres System.Security.Cryptography y como en el código usaremos un objeto StringBuilder y UTF8Encoding, también habrá que importar System.Text.

En el código de ejemplo para usar los métodos definidos en la clase UtilSHA1 (que será en la que defino los dos métodos usados) se hará una comprobación de si tanto en el nombre como en el password usado hay caracteres no válidos, los caracteres que compruebo en el método ValidarTextoClave son los caracteres: ?*%’_ y

De esa forma intentamos asegurarnos que no se pueda hacer un SQL injection, es decir, intentar acceder maliciosamente a la base de datos a la que presumiblemente se quiere acceder.

Veamos primero el código que usa los dos métodos, el de comprobar la validez del texto introducido (ValidarTextoClave) y el de generar la clave SHA1 (GenerarClaveSHA1).

Método Main con el código de prueba para usar los métodos de la clase

Como te dije antes, se pide el nombre del usuario y el password a usar para generar la cadena con la clave SHA1 (que será de 40 caracteres convertidos a mayúsculas).

Este sería el código del método Main para Visual Basic, con las importaciones de los espacios de nombres necesarios en todo el código de ejemplo:

Option Strict On
Option Infer On

Imports System

Imports System.Text
Imports System.Security.Cryptography

Module Program
    Sub Main(args As String())
        
        dim valido As Boolean
        dim usuario As String
        dim passw as String

        Do
            Console.Write("Escribe el nombre del usuario: ")
            usuario = Console.ReadLine()
            ' si el nombre del usuario tiene caracteres no permitidos, preguntar de nuevo
            valido = UtilSHA1.ValidarTextoClave(usuario)
            if not valido
                Console.WriteLine("Nombre de usuario NO VÁLIDO.")
            end if
        Loop While Not valido

        Do
            Console.Write("Escribe la clave: ")
            passw = Console.ReadLine()
            ' si la clave tiene caracteres no permitidos, preguntar de nuevo
            valido = UtilSHA1.ValidarTextoClave(passw)
            if not valido
                Console.WriteLine("La clave NO ES VÁLIDA.")
            end if
        Loop While Not valido

        ' generar la clave SHA1 y mostrarla
        dim claveSHA1 = UtilSHA1.GenerarClaveSHA1(usuario, passw)
        Console.WriteLine($"La clave SHA1 es: '{claveSHA1}'.")
            
    End Sub
End Module

 

Este sería el código del método Main para C#, con las importaciones (using) de los espacios de nombres usados en el código:

using System;

using System.Text;
using System.Security.Cryptography;

class Program
{
    static void Main(string[] args)
    {
        bool valido;
        string usuario;
        string passw;

        do
        {
            Console.Write("Escribe el nombre del usuario: ");
            usuario = Console.ReadLine();
            // si el nombre del usuario tiene caracteres no permitidos, preguntar de nuevo
            valido = UtilSHA1.ValidarTextoClave(usuario);
            if (!valido)
                Console.WriteLine("Nombre de usuario NO VÁLIDO.");
        }
        while (!valido);

        do
        {
            Console.Write("Escribe la clave: ");
            passw = Console.ReadLine();
            // si la clave tiene caracteres no permitidos, preguntar de nuevo
            valido = UtilSHA1.ValidarTextoClave(passw);
            if (!valido)
                Console.WriteLine("La clave NO ES VÁLIDA.");
        }
        while (!valido);

        // generar la clave SHA1 y mostrarla
        var claveSHA1 = UtilSHA1.GenerarClaveSHA1(usuario, passw);
        Console.WriteLine($"La clave SHA1 es: '{claveSHA1}'.");
    }
}

 

La clase UtilSHA1 con los métodos para comprobar la validez del texto y generar la clave

A continuación te muestro el código del método para validar el texto del nombre del usuario y el password o contraseña para que no contenga caracteres no deseados.

Para Visual Basic:

''' <summary>
''' Validar caracteres en la clave.
''' No se aceptan ?*%'_ ni --
''' </summary>
Public Shared Function ValidarTextoClave(laClave As String) As Boolean
    Dim sNoVale As String = "?*%'_"

    laClave = laClave.Trim()

    If laClave.IndexOf("--") > -1 Then
        Return False
    End If
    If laClave.IndexOfAny(sNoVale.ToCharArray) > -1 Then
        Return False
    End If

    Return True
End Function

 

Para C#:

/// <summary>
/// Validar caracteres en la clave.
/// No se aceptan ?*%'_ ni --
/// </summary>
public static bool ValidarTextoClave(string laClave)
{
    string sNoVale = "?*%'_";

    laClave = laClave.Trim();

    if (laClave.IndexOf("--") > -1)
        return false;
    if (laClave.IndexOfAny(sNoVale.ToCharArray()) > -1)
        return false;

    return true;
}

 

Y ahora el código con la definición del método GenerarClaveSHA1 en el que indicaremos dos cadenas: el nombre del usuario y el password y a partir de la concatenación de ambas generar el valor SHA1 producido por el método ComputeHash que en realidad devuelve un array de tipo Byte, el cual convertimos en valores hexadecimales (con dos cifras por valor) con idea de que se genere la cadena deseada de 40 caracteres en total, que finalmente convertimos en mayúsculas, pero que bien puedes dejarlo en minúsculas si así te parece mejor.

El código para Visual Basic:

''' <summary>
''' Generar una clave SHA1 para guardarla en lugar del password,
''' de esa forma no se podrá saber la clave.
''' La longitud es de 40 caracteres.
''' </summary>
''' <remarks>
''' Crear una clave SHA1 como la generada por:
''' FormsAuthentication.HashPasswordForStoringInConfigFile
''' Basado en el ejemplo de mi sitio:
''' http://www.elguille.info/NET/dotnet/comprobar_usuario_usando_base_datos_vb2003.htm
''' </remarks>
Public Shared Function GenerarClaveSHA1(nick As String, clave As String) As String
    ' Crear una clave SHA1 como la generada por 
    ' FormsAuthentication.HashPasswordForStoringInConfigFile
    ' Adaptada del ejemplo de la ayuda en la descripción de SHA1 (Clase)
    Dim enc As New UTF8Encoding
    ' Por si el usuario (nick) es nulo
    If String.IsNullOrWhiteSpace(nick) Then
        nick = ""
    Else
        nick = nick.ToLower
    End If
    Dim data() As Byte = enc.GetBytes(nick & clave)
    Dim result() As Byte

    Dim sha As New SHA1CryptoServiceProvider
    ' This is one implementation of the abstract class SHA1.
    result = sha.ComputeHash(data)

    ' Convertir los valores en hexadecimal
    ' cuando tiene una cifra hay que rellenarlo con cero
    ' para que siempre ocupen dos dígitos.
    Dim sb As New StringBuilder
    For i As Integer = 0 To result.Length - 1
        If result(i) < 16 Then
            sb.Append("0")
        End If
        sb.Append(result(i).ToString("x"))
    Next

    Return sb.ToString.ToUpper
End Function

 

El código para C#:

/// <summary>
/// Generar una clave SHA1 para guardarla en lugar del password,
/// de esa forma no se podrá saber la clave.
/// La longitud es de 40 caracteres.
/// </summary>
/// <remarks>
/// Crear una clave SHA1 como la generada por:
/// FormsAuthentication.HashPasswordForStoringInConfigFile
/// Basado en el ejemplo de mi sitio:
/// http://www.elguille.info/NET/dotnet/comprobar_usuario_usando_base_datos_cs2003.htm
/// </remarks>
public static string GenerarClaveSHA1(string nick, string clave)
{
    // Crear una clave SHA1 como la generada por 
    // FormsAuthentication.HashPasswordForStoringInConfigFile
    // Adaptada del ejemplo de la ayuda en la descripción de SHA1 (Clase)
    UTF8Encoding enc = new UTF8Encoding();
    // Por si el usuario (nick) es nulo
    if (string.IsNullOrWhiteSpace(nick))
        nick = "";
    else
        nick = nick.ToLower();
    byte[] data = enc.GetBytes(nick + clave);
    byte[] result;

    SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
    // This is one implementation of the abstract class SHA1.
    result = sha.ComputeHash(data);

    // Convertir los valores en hexadecimal
    // cuando tiene una cifra hay que rellenarlo con cero
    // para que siempre ocupen dos dígitos.
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < result.Length; i++)
    {
        if (result[i] < 16)
            sb.Append("0");
        sb.Append(result[i].ToString("x"));
    }

    return sb.ToString().ToUpper();
}

 

Nota:
El código final del método GenerarClaveSHA1 se puede simplificar para que use dos caracteres hexadecimales sin necesidad de la comparación de si el valor es menor de 16.
El código te lo muestro en el repositorio de github por si quieres intentarlo por tu cuenta 😉

 

Nota importante:
Comentarte que la generación de la clave SHA1 distingue entre mayúsculas y minúsculas, es decir, si al generar la clave SHA1 usaste Guillermo como usuario (o nick) si vuelves a generarla con el nombre en minúsculas (guillermo) el valor generado será diferente.
Esto mismo es aplicable a la contraseña o password.

 

El código completo con los proyectos para usar con .NET 5.0 (tanto con dotnet como con Visual Studio Code o con Visual Studio 2019 v16.8) está publicado en github:
Generar clave SHA1 con el nombre y password del usuario.

 

Y esto es todo… espero que te sea de utilidad… ya sabes que esa es la idea… y si te parece bien (y puedes) no estaría de más que dejaras una propina usando el enlace de PayPal 😉
Gracias.

 

Nos vemos.
Guillermo

¿Quieres aprender a programar usando .NET Core sin instalar nada?

Pues eso… me he metido en la página de instalación del .NET Core 3.0 SDK y he visto un botón con el enlace «Get Started» (ver la figura 1) y me ha llevado a la página de .NET Tutorial – Hello World in 10 minutes y en la parte de la izquierda he visto un botón con el texto Try .NET in your browser (ver figura 2) y lo he pulsado… y me ha llevado a una página en la que te va explicando las cosas básicas para crear una aplicación de consola, empezando con el clásico «Hello World!» (ver figura 3) que después ha pasado al «Hello Guillermo!» (o tu nombre) y ha seguido haciendo cambios y enseñando algunas cosas, que al menos yo ya había leído, pero así lo he tenido más claro (ver figura 4)…. bueno, es curioso más que nada… y no acaba ahí la cosa (yo no he seguido) pero se ve que sigue con otras cosas como trabajar con números, aunque esta vez ha cambiado el formato, pero básicamente es en el mismo tono (ver figuras 5 y 6), así que… te lo recomiendo ya que las cosas que incluyen son:

Análisis de las operaciones matemáticas con enteros
Análisis sobre el orden de las operaciones
Información sobre los límites y la precisión de los enteros
Operaciones con el tipo double
Operaciones con tipos de punto fijo

Eso sí, todo con puntos y comas… Smile

Las capturas

Figura 1. Get Started en la página de descarga del .NET Core 3.0 SDK
Figura 1. Get Started en la página de descarga del .NET Core 3.0 SDK

Figura 1.

Figura 2. El tutorial con el botón de Try .NET in your browser
Figura 2. El tutorial con el botón de Try .NET in your browser

Figura 2.

Figura 3. El tutorial de .NET In-Browser
Figura 3. El tutorial de .NET In-Browser

Figura 3.

Figura 4. String Interpolation
Figura 4. String Interpolation

Figura 4.

Figura 5. Aquí acaba el tutorial .NET In-Browser
Figura 5. Aquí acaba el tutorial .NET In-Browser

Figura 5.

Figura 6. El tutorial de C# sigue con el compilador In-Browser
Figura 6. El tutorial de C# sigue con el compilador In-Browser

Los enlaces:

Espero que si no te es de utilidad al menos te relaje un poco… jajajaja

Nos vemos.
Guillermo