Article de reference

Modèle-vue-vuemodèle

Frameworks pour C++ et XAML (Windows) Xamlcc Exemples Voici quelques exemples simples d'implémentation du modèle MVVM. C++ Voici un exemple utilisant C++ . Modèle.cppm : export ...

Worldlex WikiFrancaisLecture gratuite

Frameworks pour C++ et XAML (Windows)

Xamlcc

Exemples

Voici quelques exemples simples d'implémentation du modèle MVVM.

C++

Voici un exemple utilisant C++ .

Modèle.cppm :

export module wikipedia . examples . mvvm . Model ;export namespace wikipedia :: exemples :: mvvm {classe Modèle { privé : int compteur = 0 ;public : [[ nodiscard ]] int getCounter () const noexcept { return counter ; }void incrémenter () noexcept { compteur ++ ; }void décrémenter () noexcept { compteur -- ; } };}

ViewModel.cppm :

export module wikipedia . examples . mvvm . ViewModel ;import wikipedia.examples.mvvm.Model ;export namespace wikipedia :: exemples :: mvvm {classe ViewModel { privé : Modèle & modèle ;public : explicit ViewModel ( Model & m ) : model { m } {}void incrementCounter () noexcept { modèle.increment ( ) ; }void decrementCounter () noexcept { modèle.decrement ( ) ; }[[ nodiscard ]] int getCounterValue () const noexcept { return model . getCounter (); } };}

Afficher.cppm :

export module wikipedia . examples . mvvm . View ;import std ; import wikipedia . examples . mvvm . ViewModel ;using std :: cin ; using std :: string ;export namespace wikipedia :: exemples :: mvvm {classe Vue { privé : ViewModel & viewModel ;public : explicit View ( ViewModel & vm ) : viewModel { vm } {}void run ( ) { string input ; while ( true ) { std :: println ( "Compteur : {}" , viewModel.getCounterValue ( )); std :: print ( "Entrez une commande (i=incrémenter, d=décrémenter, q=quitter) : " ); std :: getline ( cin , input );if ( input == "i" ) { viewModel . incrementCounter (); } else if ( input == "d" ) { viewModel . decrementCounter (); } else if ( input == "q" ) { break ; } else { std :: println ( "Commande inconnue." ); } } } };}

L'application Main.cpp peut ensuite être exécutée comme suit :

import wikipedia.examples.mvvm.Model ; import wikipedia.examples.mvvm.View ; import wikipedia.examples.mvvm.ViewModel ;en utilisant l'espace de noms wikipedia :: exemples :: mvvm ;int main ( int argc , char * argv [ ]) { Model m ; ViewModel vm ( m ); View v ( vm ); v.run ( ); return 0 ; }

C#

Voici un exemple utilisant C# .

Modèle.cs :

espace de noms Wikipedia.Examples.Mvvm ;public class Modèle { public int Compteur { obtenir ; privé définir ; } = 0 ;public void Incrémenter () => Compteur ++ ; public void Décrémenter () = > Compteur-- ; }

ViewModel.cs :

espace de noms Wikipedia.Examples.Mvvm ;public class ViewModel { private readonly Model _model ;public ViewModel ( Modèle modèle ) { _modèle = modèle ; }public void IncrementCounter () = > _model.Increment ( ) ; public void DecrementCounter ( ) => _model.Decrement ( ) ; public int CounterValue => _model.Counter ; }

Vue.cs :

espace de noms Wikipedia.Examples.Mvvm ;utiliser le système ;public class View { private readonly ViewModel _viewModel ;public View ( ViewModel viewModel ) { _viewModel = viewModel ; }public void Run ( ) { string input = String.Empty ; while ( true ) { Console.WriteLine ( $ " Compteur : {_viewModel.CounterValue}" ) ; Console.Write ( " Entrez une commande ( i =incrémenter, d=décrémenter, q=quitter) : " ) ; input = Console.ReadLine (); switch ( input ) { case "i" : _viewModel.IncrementCounter (); break ; case " d" : _viewModel.DecrementCounter (); break ; case "q" : return ; default : Console.WriteLine ( " Commande inconnue ." ) ; break ; } } } }

L'application Main.cs peut ensuite être exécutée comme suit :

espace de noms Wikipedia.Exemples ;en utilisant Wikipedia.Examples.Mvvm ;public class Main { public static void Main () { Model model = new (); ViewModel viewModel = new ( model ); View view = new ( viewModel ); view . Run (); } }

Java

Voici un exemple utilisant Java .

Modèle.java :

paquet org.wikipedia.examples.mvvm ;public class Modèle { private int compteur = 0 ;public int getCounter () { return counter ; }public void incrémenter () { compteur ++ ; }public void décrémenter () { compteur -- ; } }

ViewModel.java :

paquet org.wikipedia.examples.mvvm ;public class ViewModel { private final Model modèle ;public ViewModel ( Model model ) { this.model = model ; }public void incrementCounter () { modèle.increment ( ) ; }public void decrementCounter () { modèle.decrement ( ) ; }public int getCounterValue () { return model.getCounter ( ) ; } }

View.java :

paquet org.wikipedia.examples.mvvm ;import java.util.Scanner ;public class View { private final ViewModel viewModel ;public View ( ViewModel viewModel ) { this.viewModel = viewModel ; }public void run ( ) { Scanner stdin = new Scanner ( System.in ) ; String input ; while ( true ) { System.out.printf ( " Compteur : % d%n" , viewModel.getCounterValue ( )); System.out.print ( " Entrez une commande (i= incrémenter , d=décrémenter, q=quitter) : " ) ; input = stdin.nextLine ( ) ; switch ( input ) { case " i" : viewModel.incrementCounter ( ); break ; case " d " : viewModel.decrementCounter ( ); break ; case " q " : return ; default : System.out.println ( " Commande inconnue . " ) ; } } } }

L'application Main.java peut ensuite être exécutée comme suit :

paquet org.wikipedia.examples ;importer org.wikipedia.examples.mvvm.* ;public class Main { public static void main ( String [] args ) { Model m = new Model (); ViewModel vm = new ViewModel ( m ); View v = new View ( vm ); v . run (); } }

Rouiller

Voici un exemple utilisant Rust .

modèle.rs :

pub struct Modèle { compteur : i32 , }impl Modèle { pub fn new () -> Self { Modèle { compteur : 0 } }pub fn get_counter ( & self ) - > i32 { self.counter }pub fn increment ( & mut self ) { self.counter + = 1 ; }pub fn decrement ( & mut self ) { self.counter - = 1 ; } }

view_model.rs :

utiliser super :: model :: Model ;pub struct ViewModel <' a > { model : & ' a mut Model , }impl <' a > ViewModel <' a > { pub fn new ( model : & ' a mut Model ) -> Self { Self { model } }pub fn increment_counter ( & mut self ) { self.model.increment ( ) ; }pub fn decrement_counter ( & mut self ) { self.model.decrement ( ) ; }pub fn get_counter_value ( & self ) - > i32 { self.model.get_counter ( ) } }

vue.rs :

utiliser std :: io ::{ self , Écrire };utiliser super :: view_model :: ViewModel ;pub struct View <' a > { view_model : & ' a mut ViewModel <' a > , }impl <' a > View <' a > { pub fn new ( view_model : & ' a mut ViewModel <' a > ) -> Self { Self { view_model } }pub fn run ( & mut self ) { loop { println! ( "Compteur : {}" , self . view_model . get_counter_value ());print! ( "Entrez la commande (i=incrémenter, d=décrémenter, q=quitter) : " ); io :: stdout (). flush (). unwrap ();let mut input : String = String :: new (); io :: stdin (). read_line ( & mut input ). unwrap (); let input : String = input . trim ();match input { "i" = > self.view_model.increment_counter ( ) , " d" => self.view_model.decrement_counter ( ) , "q" = > break , _ => println! ( "Commande inconnue." ) , } } } }

L'application main.rs pourrait alors être exécutée comme suit :

mod mvvm ;utiliser mvvm ::{ modèle :: Modèle , vue :: Vue , modèle_vue :: Modèle_vue };fn main ( ) { let mut m : Model = Model :: new (); let mut vm : ViewModel = ViewModel :: new ( & mut m ); let mut v : View = View :: new ( & mut vm ) ; v.run (); }