Gestion de la Navigation avec MVVM Light pour une application universelle

**youtpout978** · 16/07/2014, 15h11

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.

**Gold.strike** · 15/01/2015, 11h38

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,

**youtpout978** · 15/01/2015, 12h01

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.

**Gold.strike** · 15/01/2015, 12h23

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,

**youtpout978** · 15/01/2015, 15h06

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

**Gold.strike** · 15/01/2015, 16h04

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.

**Gold.strike** · 16/01/2015, 18h42

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.

**youtpout978** · 16/01/2015, 18h59

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

Gestion de la Navigation avec MVVM Light pour une application universelle [MVVM]

WinRT

Discussions similaires

Partager

Partager