question

EduardoGomez-1870 avatar image
0 Votes"
EduardoGomez-1870 asked LeonLu-MSFT edited

View Model comunicate

Hello

I am trying to improve my note app, for my final project for school.

I am trying to communicate VMs but I am using the messaging center, but it is kind of slow

This is my Notebook VM

  public NotebooksVM() {
    
             NotebooksCollection = new ObservableCollection<Notebook>();
    
             SelectedNoteBookCommand = new Command(async () => {
                 await Application.Current.MainPage.Navigation.PushAsync(new NotesPage());
                 MessagingCenter.Send(this, "data", SelectedNotebook);
                 SelectedNotebook = null;
    
             });
             ChangeLayoutCommand = new Command(OnChangeLayout);
         }
    
    
         private async Task CreateNote() {
             var result = await Application.Current.MainPage.DisplayPromptAsync(string.Empty,
                 "Notebook name?");
    
             if (!string.IsNullOrEmpty(result)) {
                 var notebook = new Notebook() {
                     Name = result,
                     UserId = App.UserId,
                     CreatedAt = DateTime.Now.ToString("ddd, MMMM yyyy")
                 };
                 await Database.InsertAsync(notebook);
                 GetNotebooksAsync();
                 await Application.Current.MainPage.Navigation.PushAsync(new NotesPage());
                 MessagingCenter.Send(this, "data", result);
             } else {
                 return;
             }
         }

As you can see in both cases I am sending the Notebook (Selected or New One) to the new Notes VM, So I can get all the notes from that notebook


Notes VM

 public Notebook RecivedNotebook { get; set; }
         public LayoutBase LayoutBase { get; set; }
         public Note SelectedNote { get; set; }
         public ICommand SelectedNoteCommand { get; set; }
         public FontImageSource Glyph { get; set; }
         public NotesVM() {
    
             Glyph = new FontImageSource() {
                 Glyph = IconFonts.FormatListBulleted,
                 FontFamily = "material",
                 Size = 44
             };
    
             LayoutBase = new LinearLayout();
    
             NotesCollection = new ObservableCollection<Note>();
    
             CreateNewNoteCommand = new Command(async () => {
                 var note = await CreateNote(RecivedNotebook);
                 await Application.Current.MainPage.Navigation.PushAsync(new EditorPage());
                 MessagingCenter.Send(this, "note", note);
                 await GetNotes(RecivedNotebook);
             });
    
             SelectedNoteCommand = new Command(async () => {
                 await Application.Current.MainPage.Navigation.PushAsync(new EditorPage());
                 MessagingCenter.Send(this, "note", SelectedNote);
                 SelectedNote = null;
    
             });
    
             MessagingCenter.Subscribe<NotebooksVM, Notebook>(this, "data",
             async (sender, data) => {
                 RecivedNotebook = data;
                 await GetNotes(RecivedNotebook);
             });
    
             ChangeLayoutCommand = new Command(OnChangeLayout);
         }
    
         private async Task GetNotes(Notebook notebook) {
             var notes = await Database.ReadAsync<Note>();
             if (notes != null) {
                 var newNotes = notes.Where(n => n.NotebookId == notebook.Id);
                 NotesCollection.Clear();
                 foreach (var item in newNotes) {
                     NotesCollection.Add(item);
                 }
             }
         }
    
         private async Task<Note> CreateNote(Notebook recivedNotebook) {
    
             var result = await Application.Current.MainPage.DisplayPromptAsync(string.Empty,
                  "Note name?");
    
             if (!string.IsNullOrEmpty(result)) {
                 var note = new Note() {
                     NotebookId = recivedNotebook.Id,
                     Title = result,
                     CreatedAt = DateTime.Now.ToString("ddd, MMMM yyyy")
                 };
                 await Database.InsertAsync(note);
                 return note;
    
             } else {
                 return null;
             }

As you can see, y receive the note, using the messeging center, and send it again to another VM

  public Note RecivedNote { get; set; }
         public EditorVM() {
    
             SaveContent = new Command(() => { UpdateNote(); });
             MessagingCenter.Subscribe<NotesVM, Note>(this, "note", (obj, item) => {
                 RecivedNote = item;
             });
         }

So I was trying to figure out, how to do this without the messaging center and ZERO code-behind

This is my project if someone wants to see it
'
https://github.com/eduardoagr/safe.Xamarin/tree/main/Safe

By the way, any features or suggestions are welcome

@WenyanZhang-MSFT


dotnet-xamarin
5 |1600 characters needed characters left characters exceeded

Up to 10 attachments (including images) can be used with a maximum of 3.0 MiB each and 30.0 MiB total.

1 Answer

WenyanZhang-MSFT avatar image
0 Votes"
WenyanZhang-MSFT answered LeonLu-MSFT edited

Hello,
Welcome to our Microsoft Q&A platform!

You can use Action instead of MessageCenter. It also can achieve ZERO code-behind.
You can have a try with following code:

NotebooksVM

 SelectedNoteBookCommand = new Command(async () => {
                 NotesPage notesPage = new NotesPage();
                 await Application.Current.MainPage.Navigation.PushAsync(notesPage);
                 NotesVM notesViewModel = (NotesVM)notesPage.BindingContext;
                 notesViewModel.RecivedNoteAction(SelectedNotebook);//invoke the action
    
                 //MessagingCenter.Send(this, "data", SelectedNotebook);
                 SelectedNotebook = null;
    
             });

NotesVM

 CreateNewNoteCommand = new Command(async () => {
                 var note = await CreateNote(RecivedNotebook);
                 await GetNotes(RecivedNotebook);
                 EditorPage editorPage = new EditorPage();
                 await Application.Current.MainPage.Navigation.PushAsync(editorPage);
                 EditorVM Editor = (EditorVM)editorPage.BindingContext;
                 Editor.RecivedNoteAction(note);//Replace MessagingCenter.Send
             });
    
 SelectedNoteCommand = new Command(async () => {
                 EditorPage editorPage = new EditorPage();
                 await Application.Current.MainPage.Navigation.PushAsync(editorPage);
                 EditorVM Editor = (EditorVM)editorPage.BindingContext;
                 Editor.RecivedNoteAction(SelectedNote);
                 //MessagingCenter.Send(this, "note", SelectedNote);
                 SelectedNote = null;
    
             });
 // Replace  MessagingCenter.Subscribe
 RecivedNoteAction = async(Notebook) =>
             {
                 RecivedNotebook = Notebook;
                 await GetNotes(RecivedNotebook);
             };

EditorVM

  public class EditorVM {
         public string Text { get; set; }
         public ICommand SaveContent { get; set; }
         public Note RecivedNote { get; set; }
         public Action<Note> RecivedNoteAction;
         public EditorVM() {
    
             SaveContent = new Command(() => { UpdateNote(); });
    
             RecivedNoteAction = (Note) =>
             {
                 RecivedNote = Note;  
             };
         }
    
         private void UpdateNote() {
             // test  out of action function
             Console.WriteLine("test------------{0}", this.RecivedNote.Title);
         }
     }

Best Regards,
Wenyan Zhang


If the response is helpful, please click "Accept Answer" and upvote it.
Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

5 |1600 characters needed characters left characters exceeded

Up to 10 attachments (including images) can be used with a maximum of 3.0 MiB each and 30.0 MiB total.