Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre expert

    Homme Profil pro
    Développeur .NET
    Inscrit en
    novembre 2010
    Messages
    1 802
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : novembre 2010
    Messages : 1 802
    Points : 3 702
    Points
    3 702
    Par défaut Gestion de la Navigation avec MVVM Light pour une application universelle
    Bonjour,

    je viens de me mettre à MVVM light sur une solution windows universal apps et je voulais savoir comment gérer la navigation entre les vues.

    Actuellement j'ai fais ça dans le ViewModel de ma première page qui sera le menu de l'application:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
     
     public class MenuViewModel : ViewModelAncestor
        {
     
            public RelayCommand<string> NavigateTo { get; set; }
     
            public MenuViewModel()
            {
                NavigateTo = new RelayCommand<string>(Goto);
            }
     
            private void Goto(string page)
            {
                switch (page)
                {
                    case "Simulator":
                        this.Frame.Navigate(typeof(SimulatorPage));
                        break;
                    default:
                        this.Frame.Navigate(typeof(SimulatorPage));
                        break;
                }
     
            }
        }
    Mon viewModelAncestor au cas où:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
     
     public class ViewModelAncestor : ViewModelBase
        {
            public Frame Frame
            {
                get
                {
                    return ((Frame)Window.Current.Content);
                }
            }
     
            #region Prise en charge de la navigation
     
            RelayCommand _goBackCommand;
            RelayCommand _goForwardCommand;
     
            /// <summary>
            /// <see cref="RelayCommand"/> utilisée pour la liaison à la propriété Command du bouton Précédent
            /// pour accéder à l'élément le plus récent de l'historique de navigation vers l'arrière, si un frame
            /// gère son propre historique de navigation.
            /// 
            /// La commande<see cref="RelayCommand"/> est configurée pour utiliser la méthode virtuelle <see cref="GoBack"/>
            /// comme action d'exécution et <see cref="CanGoBack"/> pour CanExecute.
            /// </summary>
            public RelayCommand GoBackCommand
            {
                get
                {
                    if (_goBackCommand == null)
                    {
                        _goBackCommand = new RelayCommand(
                            () => this.GoBack(),
                            () => this.CanGoBack());
                    }
                    return _goBackCommand;
                }
                set
                {
                    _goBackCommand = value;
                }
            }
            /// <summary>
            /// <see cref="RelayCommand"/> utilisée pour accéder à l'élément le plus récent du 
            /// l'historique de navigation avant, si un frame gère son propre historique de navigation.
            /// 
            /// La commande<see cref="RelayCommand"/> est configurée pour utiliser la méthode virtuelle <see cref="GoForward"/>
            /// comme action d'exécution et <see cref="CanGoForward"/> pour CanExecute.
            /// </summary>
            public RelayCommand GoForwardCommand
            {
                get
                {
                    if (_goForwardCommand == null)
                    {
                        _goForwardCommand = new RelayCommand(
                            () => this.GoForward(),
                            () => this.CanGoForward());
                    }
                    return _goForwardCommand;
                }
            }
     
            /// <summary>
            /// Méthode virtuelle utilisée par la propriété <see cref="GoBackCommand"/>
            /// pour déterminer si le <see cref="Frame"/> peut reculer.
            /// </summary>
            /// <returns>
            /// true si le <see cref="Frame"/> possède au moins une entrée 
            /// dans l'historique de navigation vers l'arrière.
            /// </returns>
            public virtual bool CanGoBack()
            {
                return this.Frame != null && this.Frame.CanGoBack;
            }
            /// <summary>
            /// Méthode virtuelle utilisée par la propriété <see cref="GoForwardCommand"/>
            /// pour déterminer si le <see cref="Frame"/> peut avancer.
            /// </summary>
            /// <returns>
            /// true si le <see cref="Frame"/> possède au moins une entrée 
            /// dans l'historique de navigation vers l'avant.
            /// </returns>
            public virtual bool CanGoForward()
            {
                return this.Frame != null && this.Frame.CanGoForward;
            }
     
            /// <summary>
            /// Méthode virtuelle utilisée par la propriété <see cref="GoBackCommand"/>
            /// pour appeler la méthode <see cref="Windows.UI.Xaml.Controls.Frame.GoBack"/>.
            /// </summary>
            public virtual void GoBack()
            {
                if (this.Frame != null && this.Frame.CanGoBack) this.Frame.GoBack();
            }
            /// <summary>
            /// Méthode virtuelle utilisée par la propriété <see cref="GoForwardCommand"/>
            /// pour appeler la méthode <see cref="Windows.UI.Xaml.Controls.Frame.GoForward"/>.
            /// </summary>
            public virtual void GoForward()
            {
                if (this.Frame != null && this.Frame.CanGoForward) this.Frame.GoForward();
            }
     
            #endregion
     
     
        }
    Et ma vue (j'ai pas encore ajouté les commandes parameter :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    <Page
        x:Class="FlyffSimulator.MenuPage"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="using:FlyffSimulator"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        mc:Ignorable="d">
     
        <Grid  Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" DataContext="{Binding Menu, Mode=TwoWay, Source={StaticResource Locator}}">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="1*"></ColumnDefinition>
                <ColumnDefinition Width="1*"></ColumnDefinition>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="1*"></RowDefinition>
                <RowDefinition Height="1*"></RowDefinition>
            </Grid.RowDefinitions>
            <Grid.Resources>
                <Style TargetType="Button" >
     
                    <Setter Property="MaxHeight" Value="300"></Setter>
                    <Setter Property="MaxWidth" Value="300"></Setter>
                </Style>
                <Style TargetType="TextBlock" >
                    <Setter Property="HorizontalAlignment" Value="Center"/>
                    <Setter Property="VerticalAlignment" Value="Center"/>
     
                </Style>
                <Style TargetType="StackPanel" >
                    <Setter Property="HorizontalAlignment" Value="Center"/>
                    <Setter Property="VerticalAlignment" Value="Center"/>
     
                </Style>
            </Grid.Resources>
            <StackPanel Grid.Column="0" Grid.Row="0" >
                <Button HorizontalAlignment="Center"  VerticalAlignment="Center" Command="{Binding NavigateTo }" >
                    <Image Source="Assets/84bbb25a-7a8a-4132-ad5b-adcf4691df54.png" ></Image>
                </Button>
                <TextBlock  x:Uid="Characters" ></TextBlock>
            </StackPanel>
            <StackPanel Grid.Column="1" Grid.Row="0" >
                <Button HorizontalAlignment="Center" VerticalAlignment="Center" Command="{Binding NavigateTo }" >
                    <Image Source="Assets/84bbb25a-7a8a-4132-ad5b-adcf4691df54.png" ></Image>
                </Button>
                <TextBlock x:Uid="Simulator"></TextBlock>
            </StackPanel>
            <StackPanel Grid.Column="0" Grid.Row="1" >
                <Button HorizontalAlignment="Center"  VerticalAlignment="Center" Command="{Binding NavigateTo }" >
                    <Image Source="Assets/84bbb25a-7a8a-4132-ad5b-adcf4691df54.png" ></Image>
                </Button>
                <TextBlock x:Uid="Simulator" ></TextBlock>
            </StackPanel>
            <StackPanel Grid.Column="1" Grid.Row="1" >
                <Button HorizontalAlignment="Center"  VerticalAlignment="Center" Command="{Binding NavigateTo }" >
                    <Image Source="Assets/84bbb25a-7a8a-4132-ad5b-adcf4691df54.png" ></Image>
                </Button>
                <TextBlock x:Uid="Parameters" ></TextBlock>
            </StackPanel>
        </Grid>
    </Page>
    Le problème c'est que je voudrais pouvoir passer des paramètres d'une page à une autre ou d'un ViewModel à un autre, gérer les différents états de mon application ...
    Comment gère-t-on ça avec MVVM light ?

    Merci pour vos réponses.

  2. #2
    Membre régulier
    Profil pro
    Inscrit en
    juillet 2006
    Messages
    187
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2006
    Messages : 187
    Points : 73
    Points
    73
    Par défaut
    Salut, je voudrais savoir comment tu t'y es pris finalement pour gérer la navigation car je suis confronté à la même problématique : je développe une application universelle W8.1/WP8.1 et j'utilise MVVM-Light.

    J'ai vu qu'il existait une nouvelle interface permettant de gérer la navigation dans la version 5 de MVVM-Light:
    http://blog.galasoft.ch/posts/2014/1...s-and-xamarin/

    J'ai suivi un tutoriel décrivant cette implémentation, mais je n'ai pas réussi à le faire marcher, et la navigation se fait en code behind:
    https://marcominerva.wordpress.com/2...mvvm-light-v5/

    Donc pourrais tu me dire comment tu t'y es pris?
    Aurais tu des liens ou des tutoriaux à me recommander?

    Merci d'avance,

  3. #3
    Membre expert

    Homme Profil pro
    Développeur .NET
    Inscrit en
    novembre 2010
    Messages
    1 802
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : novembre 2010
    Messages : 1 802
    Points : 3 702
    Points
    3 702
    Par défaut
    Salut,
    j'étais partie sur une autre bibliothèque qui s'appelle Navegar qui fonctionne avec MVVM Light dont l'auteur est français, et avec lequel j'ai pu communiqué directement sur twitter pour résoudre certain problème avec sa bibliothèque
    Voici son blog : http://blog.kopigi.fr/ et le lien vers sa bibliothèque : http://navegar.codeplex.com/
    Elle fonctionne avec les Universal Apps mais j'ai pas testé sous Windows Metro encore.

    Faudrait que je fasse un tuto de mise en place d'un projet universal apps avec MVVM et navegar un de ces jours, sinon j'ai pas testé la navigation directement intégré à MVVM light faudrai que je m'y mette.

  4. #4
    Membre régulier
    Profil pro
    Inscrit en
    juillet 2006
    Messages
    187
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2006
    Messages : 187
    Points : 73
    Points
    73
    Par défaut
    J'ai voulu testé Navegar, mais je n'avais pas réussi non plus à l'implémenter à partir de la doc fournie :
    https://navegar.codeplex.com/wikipag...=Documentation
    Etant donné le petit nombre de téléchargements du package, j'avais alors abandonné cette piste, mais si tu me dis que tu as pu l'utiliser plutôt facilement, je vais peut-être y revenir.

    De mon côté, il s'agit bien d'une Universal App, sur laquelle je voudrais utiliser une navigation de type ViewModel First, afin d'éviter le passage de données en code behind.

    Mais j'ai quelques questions spécifiques par rapport à la structure de mon projet :
    - ma MainPage est une page de login qui permet à utilisateur de s'authentifier ou de créer un compte :
    => 1. si un utilisateur s'authentifie correctement, ses infos sont enregistrées dans un fichier local et on passe à la page suivante
    => 2. ainsi au prochain lancement, on charge directement les infos de l'utilisateur depuis le fichier et on passe directement à la page suivante, sans que l'utilisateur voit la page de login
    => 3. par contre, si l'utilisateur ne parvient pas à s'authentifier, ou si il se déconnecte, on revient dans le cas 1.
    - ma HomePage est est un Hub qui contient différentes sections : message de bienvenue à l'utilisateur, liste d'articles, liste des contacts, ...
    => c'est depuis cette page que l'utilisateur pourra naviguer sur les différentes pages de ma solution

    Je me demande donc si tu penses que Navegar peut bien répondre à mes besoins?
    Avais-tu trouvé une doc un peu plus fournie que celle que j'ai mis dans le lien?

    Merci,

  5. #5
    Membre expert

    Homme Profil pro
    Développeur .NET
    Inscrit en
    novembre 2010
    Messages
    1 802
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : novembre 2010
    Messages : 1 802
    Points : 3 702
    Points
    3 702
    Par défaut
    J'avais mis en place différent procédé je ne sais plus pourquoi maintenant mais sans ça, ça ne marche pas.
    J'ai pas toujours fait au plus propre mais c'est fonctionnel.
    Ne prête pas attention au partie faisant référence au e.argument c'est dans le cas ou tu charges ton programme avec des paramètres mais pas sur que t'en ai besoin pour l'instant.

    Mon app.xaml.cs
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
     /// <summary>
            /// Invoqué lorsque l'application est lancée normalement par l'utilisateur final.  D'autres points d'entrée
            /// sont utilisés lorsque l'application est lancée pour ouvrir un fichier spécifique, pour afficher
            /// des résultats de recherche, etc.
            /// </summary>
            /// <param name="e">Détails concernant la requête et le processus de lancement.</param>
            protected override void OnLaunched(LaunchActivatedEventArgs e)
            {
    #if DEBUG
                if (System.Diagnostics.Debugger.IsAttached)
                {
                    this.DebugSettings.EnableFrameRateCounter = true;
                }
    #endif
     
                Frame rootFrame = Window.Current.Content as Frame;
     
                // Ne répétez pas l'initialisation de l'application lorsque la fenêtre comporte déjà du contenu,
                // assurez-vous juste que la fenêtre est active
                if (rootFrame == null)
                {
                    // Créez un Frame utilisable comme contexte de navigation et naviguez jusqu'à la première page
                    rootFrame = new Frame();
                    rootFrame.Tag = e.Arguments;
     
                    // TODO: modifier cette valeur à une taille de cache qui contient à votre application
                    rootFrame.CacheSize = 1;
     
                    if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
                    {
                        // TODO: chargez l'état de l'application précédemment suspendue
                    }
     
                    // Placez le frame dans la fenêtre active
                    Window.Current.Content = rootFrame;
     
                    //Pour le service de navigation
                    SimpleIoc.Default.GetInstance<INavigation>().InitializeRootFrame(rootFrame);
     
                }
                else if (!string.IsNullOrWhiteSpace(e.Arguments))
                {
                    SummonerXML summoner = Serialisation<SummonerXML>.FromXml(e.Arguments);
                    SimpleIoc.Default.GetInstance<INavigation>().NavigateTo<RecentGameViewModel>(true, new object[] { summoner.SummonerId, summoner.Region });
                }
     
     
                if (rootFrame.Content == null)
                {
    #if WINDOWS_PHONE_APP
                    // Supprime la navigation tourniquet pour le démarrage.
                    if (rootFrame.ContentTransitions != null)
                    {
                        this.transitions = new TransitionCollection();
                        foreach (var c in rootFrame.ContentTransitions)
                        {
                            this.transitions.Add(c);
                        }
                    }
     
                    rootFrame.ContentTransitions = null;
                    rootFrame.Navigated += this.RootFrame_FirstNavigated;
    #endif
     
                    // Quand la pile de navigation n'est pas restaurée, accédez à la première page,
                    // puis configurez la nouvelle page en transmettant les informations requises en tant que
                    // paramètre
                    if (!rootFrame.Navigate(typeof(MainPage), e.Arguments))
                    {
                        throw new Exception("Failed to create initial page");
                    }
                }
     
                // Vérifiez que la fenêtre actuelle est active
                Window.Current.Activate();
            }
    Mon ViewmodelLocator:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
     public class ViewModelLocator
        {
            public MainViewModel MainVM
            {
                get
                {
                    return ServiceLocator.Current.GetInstance<MainViewModel>();
                }
            }
     
            public MenuViewModel MenuVM
            {
                get
                {
     
                    return ServiceLocator.Current.GetInstance<INavigation>().GetViewModelInstance<MenuViewModel>();
                }
     
            }
     
            public SummonerViewModel SummonerVM
            {
                get
                {
     
                    return ServiceLocator.Current.GetInstance<INavigation>().GetViewModelInstance<SummonerViewModel>();
                }
            }
     
            public RecentGameViewModel RecentGameVM
            {
                get
                {
                    return ServiceLocator.Current.GetInstance<INavigation>().GetViewModelInstance<RecentGameViewModel>();
                }
            }
     
            static ViewModelLocator()
            {
                ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
     
                //Enregistrer la classe de navigation dans l'IOC et les ViewModels
                SimpleIoc.Default.Register<MainViewModel>();
     
                SimpleIoc.Default.Register<INavigation, Navigation>();
     
                //Association des vues avec leur modéle de vue 
                SimpleIoc.Default.GetInstance<INavigation>().RegisterView<MenuViewModel, MenuPage>();
                SimpleIoc.Default.GetInstance<INavigation>().RegisterView<SummonerViewModel, SummonerPage>();
                SimpleIoc.Default.GetInstance<INavigation>().RegisterView<RecentGameViewModel, RecentGamePage>();
            }
        }
    Mon app.xaml:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
            x:Class="using:MonApp.App"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="using:LolStat"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        mc:Ignorable="d"
        xmlns:vm="using:MonApp.ViewModel" 
      >
        <Application.Resources>
            <ResourceDictionary >
                <vm:ViewModelLocator x:Key="Locator" 
                                 d:IsDataSource="true"></vm:ViewModelLocator>
     
                <ResourceDictionary.MergedDictionaries >
                    <ResourceDictionary   Source="Resources/DataTemplates.xaml"></ResourceDictionary>
                    <ResourceDictionary   Source="Resources/Styles.xaml"></ResourceDictionary>
                    <ResourceDictionary   Source="Resources/Converters.xaml"></ResourceDictionary>
                </ResourceDictionary.MergedDictionaries>
     
            </ResourceDictionary>
        </Application.Resources>
    </Application>
    Mon ViewModelAncestor.cs (c'est la classe dont hérite tous mes viewmodel):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
        public class ViewModelAncestor : ViewModelBase
        {
            public Frame Frame
            {
                get
                {
                    return ((Frame)Window.Current.Content);
                }
            }
     
            private string errorMessage;
            public string ErrorMessage
            {
                get
                {
                    return errorMessage;
                }
                set
                {
                    Set(() => ErrorMessage, ref errorMessage, value);
                    ErrorVisible = string.IsNullOrEmpty(ErrorMessage) ? Visibility.Collapsed : Visibility.Visible;
                }
            }
     
            private Visibility errorVisible;
            public Visibility ErrorVisible
            {
                get
                {
                    return errorVisible;
                }
                set
                {
                    Set(() => ErrorVisible, ref errorVisible, value);
                }
            }
     
            #region Prise en charge de la navigation
     
            RelayCommand _goBackCommand;
            RelayCommand _goForwardCommand;
     
            /// <summary>
            /// <see cref="RelayCommand"/> utilisée pour la liaison à la propriété Command du bouton Précédent
            /// pour accéder à l'élément le plus récent de l'historique de navigation vers l'arrière, si un frame
            /// gère son propre historique de navigation.
            /// 
            /// La commande<see cref="RelayCommand"/> est configurée pour utiliser la méthode virtuelle <see cref="GoBack"/>
            /// comme action d'exécution et <see cref="CanGoBack"/> pour CanExecute.
            /// </summary>
            public RelayCommand GoBackCommand
            {
                get
                {
                    if (_goBackCommand == null)
                    {
                        _goBackCommand = new RelayCommand(GoBack, CanGoBack);
                    }
                    return _goBackCommand;
                }
                set
                {
                    _goBackCommand = value;
                }
            }
     
     
            /// <summary>
            /// Méthode virtuelle utilisée par la propriété <see cref="GoBackCommand"/>
            /// pour déterminer si le <see cref="Frame"/> peut reculer.
            /// </summary>
            /// <returns>
            /// true si le <see cref="Frame"/> possède au moins une entrée 
            /// dans l'historique de navigation vers l'arrière.
            /// </returns>
            public virtual bool CanGoBack()
            {
     
                return SimpleIoc.Default.GetInstance<INavigation>().CanGoBack();
            }
     
     
            /// <summary>
            /// Méthode virtuelle utilisée par la propriété <see cref="GoBackCommand"/>
            /// pour appeler la méthode <see cref="Windows.UI.Xaml.Controls.Frame.GoBack"/>.
            /// </summary>
            public virtual void GoBack()
            {
                SimpleIoc.Default.GetInstance<INavigation>().GoBack();
            }
     
     
            #endregion
     
     
        }
    Et le viewmodel de ma première page celle qui est chargé au démarrage mais qui ne contient aucun contenu elle sert juste d'initialisation, après c'est à toi d'implémenter ici ta logique pour justement redirigé vers ta page de login ou sur l’accueil si la personne est déjà logué:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
     public class MainViewModel : ViewModelAncestor
        {
            //DispatcherTimer timer;
     
            public MainViewModel()
            {
                //timer = new DispatcherTimer();
                //timer.Interval = new TimeSpan(0, 0, 0, 0, 500);
                //timer.Tick += load_Accueil;
                //timer.Start();
                var t = Context.Instance.Champions;
                Frame.Loaded += Frame_Loaded;
            }
     
            void Frame_Loaded(object sender, RoutedEventArgs e)
            {
                if (Frame.Tag != null && !string.IsNullOrWhiteSpace(Frame.Tag.ToString()))
                {
                    SummonerXML summoner = Serialisation<SummonerXML>.FromXml(Frame.Tag.ToString());
                    SimpleIoc.Default.GetInstance<INavigation>().NavigateTo<RecentGameViewModel>(true, new object[] { summoner.SummonerId, summoner.Region });
                }
                else
                {
                    SimpleIoc.Default.GetInstance<INavigation>().NavigateTo<SummonerViewModel>();
                }
            }
     
            //void load_Accueil(object sender, object e)
            //{
            //    timer.Stop();
            //    SimpleIoc.Default.GetInstance<INavigation>().NavigateTo<MenuViewModel>();
            //}
     
        }
    Si je tentais une redirection tout de suite ça plantait alors qu'en attendant que la frame soit chargé c'est parfaitement fonctionnel.

    J'espère t'avoir bien aidé, en tout cas j'aurai eu ça dès le départ j'aurais gagné un temps fou

  6. #6
    Membre régulier
    Profil pro
    Inscrit en
    juillet 2006
    Messages
    187
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2006
    Messages : 187
    Points : 73
    Points
    73
    Par défaut
    Un grand merci pour retour, je vais tester chez moi!
    J'ai contacté l'auteur de Navegar par mail également, car en suivant ses étapes d'implémentation, j'obtiens 2 erreurs :
    There is already a factory registered for GalaSoft.MvvmLight.Views.INavigationService
    Les arguments de type pour la méthode 'Navegar.Win8.INavigation.NavigateTo<TTo>(params object[])' ne peuvent pas être déduits à partir de l'utilisation. Essayez de spécifier les arguments de type de façon explicite.
    Je vais donc retenter en m'inspirant de ton code.

  7. #7
    Membre régulier
    Profil pro
    Inscrit en
    juillet 2006
    Messages
    187
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2006
    Messages : 187
    Points : 73
    Points
    73
    Par défaut
    J'arrive maintenant à naviguer entre 2 pages.

    Par contre, je ne sais pas comment récupérer les paramètres transmis lors d'un NavigateTo<>() .
    Par exemple, quand tu fais :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    SimpleIoc.Default.GetInstance<INavigation>().NavigateTo<RecentGameViewModel>(true, new object[] { summoner.SummonerId, summoner.Region });
    => Comment récupérer les paramètres summoner.SummonerId et summoner.Region sur le ViewModel "RecentGameViewModel"?

    De plus, n'est il pas possible de passer directement un objet "métier" comme paramètre?
    Quand je fais :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    Article article = new Article();
    article.id_article = 3;
    article.lien = "http://wwww.google.fr/";
    _gotoPage2Command = new RelayCommand(() =>
    {
    	SimpleIoc.Default.GetInstance<INavigation>().NavigateTo<Page2ViewModel>(this, new object[] { article}, true);
    });
    => J'obtiens une exception :
    Une exception de type 'Navegar.Win8.NavigationException' s'est produite dans Navegar.WP81.DLL mais n'a pas été gérée dans le code utilisateur
    Informations supplémentaires : Constructor on type 'TestUA.ViewModel.Page2ViewModel' not found.
    Merci d'avance pour ton retour.

  8. #8
    Membre expert

    Homme Profil pro
    Développeur .NET
    Inscrit en
    novembre 2010
    Messages
    1 802
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : novembre 2010
    Messages : 1 802
    Points : 3 702
    Points
    3 702
    Par défaut
    Bein tu peux passer ce que tu veux, en faite tu les récupères dans ton constructeur:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
            public RecentGameViewModel(long summonerId, RegionEnum region)
            {
                this.SummonerId = summonerId;
                this.Region = region;
                try
                {
                    ErrorMessage = string.Empty;
                    Loading = true;
                    LoadRecentGames();
                    HomeCommand = new RelayCommand(GoHome);
                }
                catch (Exception ex)
                {
                    ErrorMessage = ex.Message;
                }
     
            }
     
            private async void LoadRecentGames()
            {
                try
                {
                    IEnumerable<IGame> games = await GetRecentGames();
                    RecentGames = new ObservableCollection<IGame>(games);                
                }
                catch (Exception ex)
                {
                    ErrorMessage = ex.Message;
                }
                finally
                {
                    Loading = false;
                }
     
            }

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 5
    Dernier message: 19/02/2015, 19h23
  2. Choix d'un langage pour une application de gestion
    Par mister3957 dans le forum Langages de programmation
    Réponses: 6
    Dernier message: 18/02/2006, 05h39
  3. problèmes avec "include file" pour une page asp
    Par chipsense dans le forum ASP
    Réponses: 1
    Dernier message: 02/09/2005, 16h22
  4. Configurer MYSQL++ avec Dev-C++ pour une connexion à BDMySQL
    Par limouna dans le forum Installation
    Réponses: 1
    Dernier message: 24/07/2005, 22h25

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo