Impossible de voir mes binding une fois logger

Bonjour je viens de faire une formation accélérer pour pouvoir créer une app
et j'ai dus tous recommencer car une fois logguer je voulais que les info de l'utilisateur lui soit visible pour pouvoir être modifier.
Mais rien n'apparait a la place du binding dans welcomePage.XAML( j'ai tous recommencer du debut pour pouvoir deja faire fonctionner cette fonction donc ces une version de test)
Voici les différentes zone importante il me semble merci a vous et une bonne année:

A noter que j'ai rentrer manuellement la zone categoria sur firebase et qu'elle contient un texte que je devrais voir justement

Page welcomePage.XAML
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XF_Login.View.WelcomPage"
             Title="Welcom Page">
            
    <ContentPage.Content>
        <StackLayout>
            
        <bold>    <Entry Text="{Binding .categoria}" />     
            <Entry  Text="{Binding categoria.categoria}"/></bold>
            <Button x:Name="updatebtn" Text="Change Password" Command="{Binding UpdateCommand}" />
            <Button x:Name="deletebtn" Text="Delete Account" Command="{Binding DeleteCommand}"/>
            <Button x:Name="logoutbtn" Text="Logout" Command="{Binding LogoutCommand}"/>
        </StackLayout>
    </ContentPage.Content>
</ContentPage>


Page WelcomePage.XAML.CS

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using XF_Login.ViewModel;
using Firebase;

namespace XF_Login.View
{
 
 [XamlCompilation(XamlCompilationOptions.Compile)]
 public partial class WelcomPage : ContentPage
 {
        WelcomePageVM welcomePageVM;
  public WelcomPage (string email , string nome , string categoria)
  {
   InitializeComponent ();
            welcomePageVM = new WelcomePageVM(email , nome,categoria);
            BindingContext = welcomePageVM;
  }
 }
}


Page Firehelper.cs

using Firebase.Database;
using Firebase.Database.Query;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using XF_Login.Models;

namespace XF_Login.ViewModel
{

    public class FirebaseHelper
    {
        public static byte[] GetHash(string inputString)
        {
            using (HashAlgorithm algorithm = SHA256.Create())
                return algorithm.ComputeHash(Encoding.UTF8.GetBytes(inputString));
        }
        public static string GetHashString(string inputString)
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in GetHash(inputString))
                sb.Append(b.ToString("X2"));
            return sb.ToString();
        }
        public static FirebaseClient firebase = new
   <bold>>>>>>>>>>>     FirebaseClient("mon adresse est cacher mais bien dans le code et les info sont bien ecrite sur firebase au moment de l'enregistrement de l'user ");
</bold>
        //Read All    
        public static async Task<List<Users>> GetAllUser()
        {
            try
            {
                var userlist = (await firebase
                .Child("Users")
                .OnceAsync<Users>()).Select(item =>
                new Users
                {
                    Email = item.Object.Email,
                    Password = item.Object.Password,
                    Nome = item.Object.Nome,
                    Categoria = item.Object.Categoria
                }).ToList();
                return userlist;
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
                return null;
            }
        }

        //Read     
        public static async Task<Users> GetUser(string email, string nome ,string categoria)
        {
            try
            {
                var allUsers = await GetAllUser();
                await firebase
                .Child("Users")
                .OnceAsync<Users>();
                return allUsers.Where(a => a.Email == email).FirstOrDefault();
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
                return null;
            }
        }


        //Insert a user    
        public static async Task<bool> AddUser(string email, string password, string nome, string categoria)
        {
            try
            {
                await firebase
                .Child("Users")
                .PostAsync(new Users(){ Email = email, Password = GetHashString(password), Nome = nome, Categoria = categoria });
                return true;
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
                return false;
            }
        }

        //Update     
        public static async Task<bool> UpdateUser(string email, string password, string nome, string categoria)
        {
            try
            {
                var toUpdateUser = (await firebase
                .Child("Users")
                .OnceAsync<Users>()).Where(a => a.Object.Email == email).FirstOrDefault();
                await firebase
                .Child("Users")
                .Child(toUpdateUser.Key)
                .PutAsync(new Users(){ Email = email, Password = GetHashString(password), Nome = nome, Categoria = categoria });
                return true;
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
                return false;
            }
        }

        //Delete User    
        public static async Task<bool> DeleteUser(string email)
        {
            try
            {
                var toDeletePerson = (await firebase
                .Child("Users")
                .OnceAsync<Users>()).Where(a => a.Object.Email == email).FirstOrDefault();
                await firebase.Child("Users").Child(toDeletePerson.Key).DeleteAsync();
                return true;
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
                return false;
            }
        }

    }
}


Page WelcomePageVM.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Text;
using Xamarin.Forms;

namespace XF_Login.ViewModel
{
    public class WelcomePageVM : INotifyPropertyChanged
    {
        public WelcomePageVM(string email2, string nom2,string categoria2)
        {
            Email = email2;
            Nome = nom2;
            categoria = categoria2;
        }

        private string email;

        public string Email
        {
            get { return email; }
            set { email = value; }
        }

        private string nome;

        public string Nome
        {
            get { return nome; }
            set { nome = value; }

        }

        private string categoria;

        public string Categoria
        {
            get { return categoria; }
            set { categoria = value; }
        }

        private string password;
        public event PropertyChangedEventHandler PropertyChanged;
        public string Password
        {
            get { return password; }
            set
            {
                password = value;
                PropertyChanged(this, new PropertyChangedEventArgs("Password"));
            }
        }
        

        public Command UpdateCommand
        {
            get { return new Command(Update); }
        }
        public Command DeleteCommand
        {
            get { return new Command(Delete); }
        }
        //For Logout
        public Command LogoutCommand
        {
            get
            {
                return new Command(() =>
                {
                    App.Current.MainPage.Navigation.PopAsync();
                });
            }
        }

       
        //Update user data
        private async void Update()
        {
            try
            {
                if (!string.IsNullOrEmpty(Password))
                {
                    var isupdate = await FirebaseHelper.UpdateUser(Email, Password, Nome, Categoria);
                    if (isupdate)
                        await App.Current.MainPage.DisplayAlert("Update Success", "", "Ok");
                    else
                        await App.Current.MainPage.DisplayAlert("Error", "Record not update", "Ok");
                }
                else
                    await App.Current.MainPage.DisplayAlert("Password Require", "Please Enter your password", "Ok");
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
            }
        }

        //Delete user data
        private async void Delete()
        {
            try
            {
                var isdelete = await FirebaseHelper.DeleteUser(Email);
                if (isdelete)
                    await App.Current.MainPage.Navigation.PopAsync();
                else
                    await App.Current.MainPage.DisplayAlert("Error", "Record not delete", "Ok");
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
            }
        }
    }
}


Page LoginViewModel.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Text;
using Xamarin.Forms;

namespace XF_Login.ViewModel
{
    public class WelcomePageVM : INotifyPropertyChanged
    {
        public WelcomePageVM(string email2, string nom2,string categoria2)
        {
            Email = email2;
            Nome = nom2;
            categoria = categoria2;
        }

        private string email;

        public string Email
        {
            get { return email; }
            set { email = value; }
        }

        private string nome;

        public string Nome
        {
            get { return nome; }
            set { nome = value; }

        }

        private string categoria;

        public string Categoria
        {
            get { return categoria; }
            set { categoria = value; }
        }

        private string password;
        public event PropertyChangedEventHandler PropertyChanged;
        public string Password
        {
            get { return password; }
            set
            {
                password = value;
                PropertyChanged(this, new PropertyChangedEventArgs("Password"));
            }
        }
        

        public Command UpdateCommand
        {
            get { return new Command(Update); }
        }
        public Command DeleteCommand
        {
            get { return new Command(Delete); }
        }
        //For Logout
        public Command LogoutCommand
        {
            get
            {
                return new Command(() =>
                {
                    App.Current.MainPage.Navigation.PopAsync();
                });
            }
        }

       
        //Update user data
        private async void Update()
        {
            try
            {
                if (!string.IsNullOrEmpty(Password))
                {
                    var isupdate = await FirebaseHelper.UpdateUser(Email, Password, Nome, Categoria);
                    if (isupdate)
                        await App.Current.MainPage.DisplayAlert("Update Success", "", "Ok");
                    else
                        await App.Current.MainPage.DisplayAlert("Error", "Record not update", "Ok");
                }
                else
                    await App.Current.MainPage.DisplayAlert("Password Require", "Please Enter your password", "Ok");
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
            }
        }

        //Delete user data
        private async void Delete()
        {
            try
            {
                var isdelete = await FirebaseHelper.DeleteUser(Email);
                if (isdelete)
                    await App.Current.MainPage.Navigation.PopAsync();
                else
                    await App.Current.MainPage.DisplayAlert("Error", "Record not delete", "Ok");
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Error:{e}");
            }
        }
    }
}


EDIT : Ajout du LANGAGE dans les balises de code (la coloration syntaxique).
Explications disponibles ici :
https://codes-sources.commentcamarche.net/faq/10686-le-nouveau-codes-sources-comment-ca-marche#balises-code

Merci d'y penser dans tes prochains messages.

Cordialement votre Comme disait M. GABIN :<< il y a une chose que je sais , c est que l'on ne sait jama­is ! >> 

>><gras>Pensez juste a cocher vos problème résolus quand ils le sont (en haut a droite

20 réponses

  • Votes
  • Date
  • Date décroissante
Résumé de la discussion

Le fil porte sur un binding Xamarin.Forms qui n'affiche pas les données utilisateur dans WelcomePage et empêche la modification des informations récupérées sur Firebase par l'utilisateur. Des échanges soulignent que les bindings doivent viser la propriété Categoria avec la casse exacte et que le ViewModel doit notifier les changements via INotifyPropertyChanged; le constructeur doit transmettre correctement Email, Nome et Categoria. D'autres éléments pointent des risques de doublons de WelcomPage et d'incohérences de binding, mais la correction clé reste le respect de la casse et l'usage de la propriété Categoria dans le XAML et le VM.

Bobot (l’IA à votre service)
  1. Bonsoir

    Maintenant que Baladur a corrigé ta coloration syntaxique (voir le lien qu’il a ajouté tout en bas de ton message) on y voit plus clair.
    Merci à lui.

    Le Xaml est sensible à la casse.
    Ta propriété c’est Categoria, pas .categoria et encore moins categoria.categoria
    1. Merci beaucoup pour la correction syntaxique.
      Oui en effet j’ai déjà essayer sans le point et en majuscule mais rien ne s’affiche ..
      1. Il doit y avoir un second soucis.
        Je n’ai jamais codé avec Xamarain, il y a peut-être des différences avec WPF qui ne me sautent pas aux yeux

        As tu mis des points d’arrêt
        • dans le constructeur de la page pour vérifier que email, nome et categoria ont bien une valeur?
        • dans le constructeur du view modèle et vérifié en pas à pas qu’il se déroule bien?
        • dans les getter et setter des propriétés pour voir si à l'exécution ça y passe?

        Est ce que les commandes fonctionnent?
        Dans le modèle, Categoria ne déclenche pas PropertyChanged, ça peut venir de là
        1. Aïe alors pour répondre plus ou moins à ta question:categoria a bien une valeur (je la voit sur firebase dans l’user connecter )

          Je regarderais cette après midi mais par contre quand je met email à la place de categoria jai bien l’e-mail binder

          Pis les commandes fonctionne (delete,update et logout)

          Pis c’est quoi les point d’arrêt dont tu parle ?
      2. Encore une petite question. A quoi pense tu quand tu écris il doit y avoir des différences avec Wpf ?
        1. Ce n’est pas parce qu’il y a une valeur dans la base de données qu’elle « arrive » jusqu’au modèle.
          Et le fait que avec l’email cela fonctionne conforte cette hypothèse (sans pour autant balayer les autres....)

          Pour bien coder il y a trois choses essentielles
          • avoir une certaine logique
          • connaitre les bases des langages utilisés
          • savoir utiliser les outils de déboggage à bon escient.


          Le 3ème point n’est manifestement pas acquis, alors avant d’aller plus loin, il faut que tu lises entièrement ce tuto https://docs.microsoft.com/fr-fr/visualstudio/debugger/debugger-feature-tour?view=vs-2019
          (Le point d’arrêt étant le premier outil décrit, mais la suite est tout aussi essentielle)

          Une fois fait la première chose à vérifier c’est qu’ici
            public WelcomPage (string email , string nome , string categoria)
            {
             InitializeComponent ();
                      welcomePageVM = new WelcomePageVM(email , nome,categoria);
                      BindingContext = welcomePageVM;
            }


          Et là

                  public WelcomePageVM(string email2, string nom2,string categoria2)
                  {
                      Email = email2;
                      Nome = nom2;
                      categoria = categoria2;
                  }

          Il y a bien une valeur dans les paramètres categoria et categoria2

          Concernant les différences avec WPF, par exemple on utilise des Windows et le modèle est bindé sur la propriété DataContext, ici c’est ContentPage et la propriété BindingContext
          Ça c’était facile à interpréter, mais s’il y a des subtilités moins évidentes, je passe forcément à côté.

          PS je viens de m’apercevoir que tu as mis 2 fois le code de WelcomePageVM et pas celui de modele de login.

          1. Ok merci beaucoup je regarde sa .
            Et pis effectivement j'ai pas mis

            Page LoginViewModel.cs la voici donc :

            using System;
            using System.Collections.Generic;
            using System.ComponentModel;
            using System.Security.Cryptography;
            using System.Text;
            using System.Windows.Input;
            using Xamarin.Forms;
            using XF_Login.View;
            
            namespace XF_Login.ViewModel
            {
                public class LoginViewModel : INotifyPropertyChanged
                {
                    public static byte[] GetHash(string inputString)
                    {
                        using (HashAlgorithm algorithm = SHA256.Create())
                            return algorithm.ComputeHash(Encoding.UTF8.GetBytes(inputString));
                    }
                    public static string GetHashString(string inputString)
                    {
                        StringBuilder sb = new StringBuilder();
                        foreach (byte b in GetHash(inputString))
                            sb.Append(b.ToString("X2"));
                        return sb.ToString();
                    }
            
            
                    private string email;
                    public string Email
                    {
                        get { return email; }
                        set
                        {
                            email = value;
                            PropertyChanged(this, new PropertyChangedEventArgs("Email"));
                        }
                    }
                    
            
                    private string nome;
                    public string Nome
                    {
                        get { return nome; }
                        set
                        {
                            nome = value;
                            PropertyChanged(this, new PropertyChangedEventArgs("Nome"));
                        }
                    }
                    private string categoria;
                    public string Categoria
                    {
                        get { return categoria; }
                        set
                        {
                            categoria = value;
                            PropertyChanged(this, new PropertyChangedEventArgs("Categoria"));
                        }
                    }
                    private string password;
                    public event PropertyChangedEventHandler PropertyChanged;
                    public string Password
                    {
                        get { return password; }
                        set
                        {
                            password = value;
                            PropertyChanged(this, new PropertyChangedEventArgs("Password"));
                        }
                    }
                    public Command LoginCommand
                    {
                        get
                        {
                            return new Command(Login);
                        }
                    }
                    public Command SignUp
                    {
                        get
                        {
                            return new Command(() => { App.Current.MainPage.Navigation.PushAsync(new XF_SignUpPage()); });
                        }
                    }
                    private async void Login()
                    {
                        //null or empty field validation, check weather email and password is null or empty
                        if (string.IsNullOrEmpty(Email) || string.IsNullOrEmpty(Password))
                            await App.Current.MainPage.DisplayAlert("Empty Values", "Please enter Email and Password", "OK");
                        else
                        {
                            //call GetUser function which we define in Firebase helper class
                            var user = await FirebaseHelper.GetUser(Email , Nome ,Categoria);
                            //firebase return null valuse if user data not found in database
                            if (user != null)
                                if (Email == user.Email && GetHashString(Password) == user.Password)
                                {
                                    await App.Current.MainPage.DisplayAlert("Login Success", "", "Ok");
                                    //Navigate to Wellcom page after successfuly login
                                    //pass user email to welcom page
            
                                    await App.Current.MainPage.Navigation.PushAsync(new WelcomPage( email, nome,categoria));
                                    
                                }
                                else
                                    await App.Current.MainPage.DisplayAlert("Login Fail", "Please enter correct Email and Password", "OK");
                            else
                                await App.Current.MainPage.DisplayAlert("Login Fail", "User not found", "OK");
                        }
                    }
                }
            }

            1. Pas moyen de trouver , je me prend la tête dessus et je reste bloquer la ...
              quand je teste avec le debuggeur sa execute le programme normalement sans s'arrêter a mes point d'arrêt ..(ou s'a ne les atteint même pas ..)
              Une bonne nuit de sommeil fera sans doute du bien :-)

              1. OKeee alors je viens de vérifier ou tu m'avais dis de voir si j'avais une value et résultat = categoria (null) string

                A part sur l'email je n'est donc aucune valeur qui arrive

                Part contre ici dans loginViewModel.CS

                await Application.Current.MainPage.Navigation.PushAsync(new WelcomPage( email, nome,categoria))


                J'ai bien toutes les value qui sont lus
                1. Alors on avance..... un peu.
                  Dans WelcomPage, tu ne peux pas afficher Categoria puisqu'il ne l'a pas.

                  Mais en même temps, tu dis qu'à cette ligne
                  await Application.Current.MainPage.Navigation.PushAsync(new WelcomPage( email, nome,categoria))


                  Il y a la valeur dans categoria. Ce qui est paradoxal.

                  Peux tu confirmer qu'il s'agit bien de la ligne numéro 102 dans le message n°7?

                  Si oui, essaye de mettre un point d'arrêt là, et d'exécuter à pas à pas détaillé, pour voir si tu vas bien dans le constructeur qui va bien et que les valeurs sont conservées.
                  1. Oui je confirme c’est bien cette ligne de loginViewmodel.

                    Je devrais voir quoi comme constructeur qui va bien ?
                2. Si par mégarde, tu as 2 classes qui s'appellent WelcomPage (dans 2 espaces de nom différents) et que celle qui est vraiment utilisée n’est pas celle que tu crois.
                  Sans trop y croire cela dit
                  1. je crois avoir dis une bêtise car j'ai mal lus concernant les retour de value avec la page Viewmodel :

                3. OK, donc c'est avant que l'info se perd.
                  1. Donc si je comprends l’erreur doit être dans firehelper?
                4. Est ce que dans la page de login, l'utilisateur est sensé saisir le nom et la catégorie?
                  1. He non effectivement pas ..
                    Je vais enlever tous sa dans la page Login
                5. Ok alors dans ce bout de code regarde mes commentaires (peu importe que tu l'aies modifié depuis, ça te servira)

                                  //Nome et Categoria sont nulls
                                  var user = await FirebaseHelper.GetUser(Email , Nome ,Categoria);
                                  //quoi qu'il se passe dans la méthode GetUser, ils sont toujours null, car se sont des type valeurs
                                  //par contre la méthode retourne un user....
                  
                                  if (user != null)
                                      if (Email == user.Email && GetHashString(Password) == user.Password)
                                      {
                                          await App.Current.MainPage.DisplayAlert("Login Success", "", "Ok");
                  
                                          //pourquoi ne pas utiliser user?
                                          //Plus pourquoi, le constructeur de WelcomPage prend 3 string en paramètre et pas directement user?
                                          await App.Current.MainPage.Navigation.PushAsync(new WelcomPage( email, nome,categoria));
                                          
                                      }


                  Mais plus encore dans ce bout de code
                          public static async Task<Users> GetUser(string email, string nome ,string categoria)
                          {
                              try
                              {
                                  var allUsers = await GetAllUser();
                                  await firebase
                                  .Child("Users")
                                  .OnceAsync<Users>();
                                  return allUsers.Where(a => a.Email == email).FirstOrDefault();
                              }
                              catch (Exception e)
                              {
                                  Debug.WriteLine($"Error:{e}");
                                  return null;
                              }
                          }


                  Tu ne fais rien de nome et categoria.
                  Une règle de bon sens veut qu'une méthode ne prend en paramètre que le strict nécessaire, ça évite de laisser croire (même à soi-même) que des données inutiles, servent à quelque chose.

                  PS, si tu ne sais pas ce qu'est un type valeur, et de fait un type référence, il est indispensable de lire https://codes-sources.commentcamarche.net/faq/750-la-difference-entre-les-types-valeur-et-les-types-reference
                  1. Excellent merci pour l’explication je vais regarder sa cette après-midi.
                    En tous cas merci beaucoup de ton aide

                    J’ai quand même beaucoup de mal à m’imaginer la Logic de ces Value

                    Si je ne mes pas string nome et string categoria dans welcomepage :pourrais je quand même binder mes value ?
                  2. A voilà donc si je comprends bien le simple faite de mettre user à la place de email,nome,et categoria fais référence à toutes les données de user ?
                  3. @toflfouRéférence ayant un sens précis en programmation, on va formuler autrement mais en gros oui.
                    Je tache de te faire un exemple simple dans la soirée ou le week-end
                  4. @Utilisateur anonymeje te remercie encore beaucoup de t'on implications .
                    Désoler pour toutes ces questions mais c'est vrai que c'est tellement intéressant que c'est vraiment cool de ta part
                6. Alors on a une classe Personne
                      public class Personne : INotifyPropertyChanged
                      {
                          #region INotifyPropertyChanged
                          public event PropertyChangedEventHandler PropertyChanged;
                          /// <summary>
                          /// Déclenche PropertyChanged
                          /// </summary>
                          /// <param name="Proprietes"></param>
                          private void GenerePropertyChanged(params string[] Proprietes)
                          {
                              if (this.PropertyChanged != null)
                                  foreach (string p in Proprietes)
                                      PropertyChanged(this, new PropertyChangedEventArgs(p));
                          }
                  
                          #endregion
                  
                          private string nom;
                          /// <summary>
                          /// Nom de la personne
                          /// </summary>
                          public string Nom
                          {
                              get { return nom; }
                              set
                              {
                                  if (nom != value)
                                  {
                                      nom = value;
                                      GenerePropertyChanged("Nom", "NomComplet");
                                  }
                              }
                          }
                  
                          private string prenom;
                          /// <summary>
                          /// Prénom de la personne
                          /// </summary>
                          public string Prenom
                          {
                              get { return prenom; }
                              set
                              {
                                  if (prenom != value)
                                  {
                                      prenom = value;
                                      GenerePropertyChanged("Prenom", "NomComplet");
                                  }
                              }
                          }
                  
                          /// <summary>
                          /// Nom et prénom de la personne
                          /// </summary>
                          public string NomComplet
                          {
                              get { return string.Format("{0} {1}", prenom, nom); }
                          }
                  
                  
                      }
                  


                  une méthode qui simule la recherche dans la BDD
                          private Personne GetPersonne(int ID)
                          {
                              if (ID == 1)
                                  return new Personne { Nom = "Di", Prenom = "Alain" };
                  
                              return null;
                          }

                  Note qu'il n'y a besoin que de l'ID, il n'y a donc que ce paramètre

                  Un bout de code qui va permettre de demander le lancement de la fenêtre d'affichage.
                              Personne user = GetPersonne(1);//on cherche la bonne personne
                              Window1 fenetre = new Window1(user); // on initialise la fenêtre
                              fenetre.Show();//on affiche la fenetre

                  C'est un peu différent de Xamarin, mais avec les commentaires ça se comprend

                  Le view model
                      /// <summary>
                      /// Il faudrait implémenter INotifyPropertyChanged
                      /// </summary>
                      public class PersonneViewModel
                      {
                          /// <summary>
                          /// Le constructeur prend une personne en paramètre
                          /// Personne est un type référence, si on modifie quelqu'un ici, c'est le même que dans la méthode appelante
                          /// </summary>
                          /// <param name="Quelquun"></param>
                          public PersonneViewModel(Personne Quelquun)
                          {
                              Nom = Quelquun.Nom;//on affecte les propriétés, ce sont des types valeurs, si on modifie Nom, ça ne modifie pas Quelquun.Nom
                              Prenom = Quelquun.Prenom;
                              NomComplet = Quelquun.NomComplet;
                          }
                  
                          public string Nom { get;  set; }
                  
                          public string Prenom { get;  set; }
                  
                          public string NomComplet { get;  set; }
                      }


                  Le xaml
                  <Window x:Class="Test_WPF.Window1"
                          xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                          xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                          xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                          xmlns:local="clr-namespace:Test_WPF"
                          mc:Ignorable="d"
                          Title="Window1" Height="200" Width="160" DataContext="{Binding}">
                      <Grid>
                          <TextBox Text="{Binding Nom}" Height="20" Width="100" Margin="30,30, 0, 0" HorizontalAlignment="Left" VerticalAlignment="Top"/>
                          <TextBox Text="{Binding Prenom}" Height="20" Width="100" Margin="30,60, 0, 0" HorizontalAlignment="Left" VerticalAlignment="Top"/>
                          <TextBlock Text="{Binding NomComplet}" Height="20" Width="100" Margin="30,90, 0, 0" HorizontalAlignment="Left" VerticalAlignment="Top"/>
                      </Grid>
                  </Window>

                  là aussi, c'est un peu différent de Xamarin, mais ça me paraît lisible

                  et le code behind de la fenêtre
                  <Window x:Class="Test_WPF.Window1"
                          xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                          xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                          xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                          xmlns:local="clr-namespace:Test_WPF"
                          mc:Ignorable="d"
                          Title="Window1" Height="200" Width="160" DataContext="{Binding}">
                      <Grid>
                          <TextBox Text="{Binding Nom}" Height="20" Width="100" Margin="30,30, 0, 0" HorizontalAlignment="Left" VerticalAlignment="Top"/>
                          <TextBox Text="{Binding Prenom}" Height="20" Width="100" Margin="30,60, 0, 0" HorizontalAlignment="Left" VerticalAlignment="Top"/>
                          <TextBlock Text="{Binding NomComplet}" Height="20" Width="100" Margin="30,90, 0, 0" HorizontalAlignment="Left" VerticalAlignment="Top"/>
                      </Grid>
                  </Window>


                  Et voilà
                  1. Merci beaucoup je regarde sa demain .
                    Tous ce que je sais c’est que quand je créer un nouvelle utilisateur en rentrant categoria nom ect et que je clique sur créer l’utilisateur..tous apparaît sur la page welcome page ..
                    Mais si je me déconnecte et me reconnecte ..plus rien Comme si j’ai merder au niveau du firebasehelper ..
                    Une bonne soirée et merci encore
                    1. REbonjour , alors j'ai essayer de bien regarder mais je n'est toujours rien qui avance ..
                      Rien que sur la page Firehelper je n'est aucune value apart sous email et password après login dans le débogguer comme si aucune données n'étais reçus depuis firebase ..
                      Je suis prêt a abandonner tellement j'ai deja passer des heures la dessus pour aucun résultat.
                      Merci en tous cas d'avoir voulus m'aider , je comprendrais si aussi si tu laches l'affaire.
                      Une bonne journée en tous cas
                      1. Bonjour
                        Ton dernier message ne peut pas me permettre de t’aider.
                        Tu as essayé de regarder quoi mon exemple qui est en wpf? Ou ton code en fonction de mon exemple?

                        Si tu as modifié ton code, tu ne l’a pas posté donc je ne peux pas me pencher sur ces modifs pour voir là où ça coince.

                        Par contre, il est évident que tu manques de bases.
                        Coder en XAML (WPF ou Xamarin peu importe) demande de connaitre
                        • correctement les bases de C#
                        • avoir une vue d’ensemble de la programmation objet (tout le binding repose sur l’objet)


                        Et là, il me semble que le C# n’est pas assez solide et que l’objet tu ne l’as pas du tout.
                        Il serait certainement plus efficace de prendre quelques jours pour apprendre tout ça et revenir à ton application après.

                        Pour les bases de C#, ce cours est excellent https://tahe.developpez.com/dotnet/csharp/ ne snobe pas les premiers chapitres ;)

                        Pour l’objet, il y a beaucoup de tutos et de cours en ligne, mais beaucoup sont académiques et donc pas forcément clairs pour un autodidacte.
                        J’ai fini par écrire mon propre tuto qui reflète mon parcours autodidacte, en espérant qu’il serait utile à d’autres
                        https://codes-sources.commentcamarche.net/faq/11239-la-programmation-objet-appliquee-a-net-par-l-exemple-partie-1-sur-3

                        1. Bonjour dans le message 18 tu m’a dis d’utiliser user mais je le met ou cette user ?
                          Ensuite j’ai essayer de le mettre en paramètre dans welcome page en le déclarant dans chaque page mais sa m’écris

                          Conversion impossible de models.users en string ..
                      2. Tu vois, c'est ça que je veux dire par
                        Et là, il me semble que le C# n’est pas assez solide et que l’objet tu ne l’as pas du tout.
                        .

                        Par ce que c'est évident que user ne se convertit pas en string.

                        Vraiment, tu gagnerais du temps et de l'énergie à apprendre les bases.

                        PS dans mon exemple (en WPF certes), j'ai utilisé user
                        1. Ton exemple comme tu le dis est déjà en WPF se qui me mélange encore plus les pédales quand j’essaye de comprendre ..
                          Ensuite j’utilise firebase dans mon code que j’ai pries sur GitHub..donc apparemment il ne s’agit pas juste de vérifier les objets mais plutôt de changer carrément le code ..Après sur les codes que j’ai poster en haut sont juste selon-toi ?

                          Ou voit tu une erreur qui empêche d’avoir une donnée?
                          Je vais regarder et surtout me débrouiller avec ce truc .
                          Merci en tous cas de test commentaire.
                      3. Je vais enfoncer des portes ouvertes:
                        • les données sont dans firebase => pas de problème d’enregistrement
                        • tu ne voies pas les enregistrements => ton code est incorrect.


                        Par contre, je m’aperçois que j’ai fait une boulette en copiant collant le dernier bout de code, au lieu du code behind de la fenêtre, j’ai remis le xaml.
                        Je reporterai ça ce soir

                        Ok WPF est un différent de Xamarin, mais ici les différences sont principalement dans le Xaml (et si tu as bien corrigé « .categoria », tu n’as à priori pas de problème de xaml).

                        La seule différence en code behind sera dans le bout code qui manque, avec un commentaire qui te dit comment ça doit être pour toi (en fonction de ce que j’ai vu dans ton code).

                        Mais (je sais j’insiste), ton vrai problème c’est les bases.
                        Je vais faire une analogie mathématique.
                        Je suppose que calculer 4 au carré ne te pose aucun problème.
                        Parce que tu sais que 4^2 = 4*4. Et que tu as appris la table du 4.
                        Et avant d’avoir appris les tables de multiplications, tu as appris que multiplier c’est additionner plusieurs fois le même nombre, donc 4*4 = 4+4+4+4.
                        Et avant tout ça, tu as appris à additionner.

                        Et bien ton soucis d’aujourd’hui, c’est un calcul de puissance alors que tu es en train d’apprendre l’addition.
                        Si tu en étais aux tables de multiplication, mon exemple, même incomplet, t’aurais parlé et peut-être même suffit.

                        1. Voilà le code behind de la page xaml
                                  public Window1(Personne Quelquun)
                                  {
                                      InitializeComponent();
                                      this.DataContext = new PersonneViewModel(Quelquun); //on binde la fenetre sur le view model
                                      //ce qui pour toi doit correspondre à 
                                      //BindingContext = new PersonneViewModel(Quelquun);
                                  }