Erste öffentliche Variable von geröstetem Seite

Question

ich Instancing eine andere Seite, und ich einen Wert zuweisen zu einem seiner öffentlichen Eigenschaften („EinWert“) wie folgt aus:

 _btnGotoOtherPage.Clicked += async (sender, e) => 
     { 
      OtherPage _otherpage = new OtherPage; 
      _otherpage.SomeValue = 1033; 
      await Navigation.PushAsync(_otherpage); 
      return; 
     }; 

Innerhalb dieses „_otherpage“, den Benutzer kann diesen Wert ändern.

Wenn "_otherpage" aufgerufen wird, möchte ich die "SomeValue" Variable ansehen und etwas damit machen.

MessagingSystem wäre nicht das, was ich brauche, weil ich nicht über die Wertänderung benachrichtigt werden möchte. Ich will nur wissen, was dieser Wert ist, wenn "_otherpage" gepoppt wird.

Ich möchte auch nicht Binding (wenn möglich!) Verwenden, weil ich fühle, es ist schwer zu organisieren, wenn ich mit vielen solcher Variablen zu tun habe.

Ist es möglich, dies mit einem Ereignis zu tun?

Mein Traum Lösung wäre (Pseudocode):

private void OnPagePopped() 
{ 
    int iNewValue = PoppedPage.SomeValue; 
} 

Danke.

Answer 1

In Seite A:

MessagingCenter.Subscribe<string>(this, "SomeMessage", (s) => HandleMessage(s)); 

In Seite B:

MessagingCenter.Send<string>("SenderOrAnythingElse", "SomeMessage"); 

Answer 2

In SeiteB gibt es öffentliche Variable:

public int SomeValue { get; set; }     

Nun zeigen wir SeiteB:

PageB nPageB = new PageB; 
await Navigation.PushAsync(nPageB); 

In nPageB kann der Benutzer jetzt SeiteB öffentlicher Variable

//we track the "Disappearing" event of the page. 
//When it occurs, we get the value 

nPageB.Disappearing += async (sender1, e1) => 
{ 
    Debug.WriteLine("New value is: " + nPage.SomeValue.ToString()); 
}; 

Answer 3

Dies ist, wie ich es mit meinen Pop-ups zu tun ändern, aber es kann auf die gleiche Art und Weise mit dem Seitenstil verwendet werden.

Heres mein kleines Beispiel erwartet MainPage = new NavigationPage(new Page1());

Es ist im Grunde über ein Task auf der Seite, wo das öffentliche Eigentum sitzt. Diese Aufgabe kann den Wert der öffentlichen Eigenschaft zurückgeben. Die Aufgabe wird in der OnDisappearing-Überschreibung abgeschlossen und die öffentliche Eigenschaft zurückgegeben.

den Wert erhalten zurück, drücken Sie die Seite und warten auf die Aufgabe page.PagePoppedTask

using System; 
using System.Threading.Tasks; 
using Xamarin.Forms; 

namespace MVVMTests 
{ 
    /// <summary> 
    /// A base implementation for a page, that holds a task, 
    /// which can be completed and returns a value of type of the generic T 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    public class ResultContentPage<T> : ContentPage 
    { 
      public Task<T> PagePoppedTask { get { return tcs.Task; } } 
      private TaskCompletionSource<T> tcs; 

      public ResultContentPage() 
      { 
       tcs = new TaskCompletionSource<T>(); 
      } 

      /// <summary> 
      /// Completes the task and sets it result 
      /// </summary> 
      /// <param name="result"></param> 
      protected /* virtual */ void SetPopupResult(T result) 
      { 
       if (PagePoppedTask.IsCompleted == false) 
        tcs.SetResult(result); 
      } 
    } 

    /// <summary> 
    /// Page1 exists of one button, that creates the Page2, assigns a value to a prop on the Page2 
    /// and then awaits the PagePoppedTask of Page2 
    /// </summary> 
    public class Page1 : ContentPage 
    { 
     public Page1() 
     { 
      var button = new Button() 
      { 
       Text = "Go to page 2" 
      }; 
      button.Clicked += Button_Clicked; 

      Content = button; 
     } 

     private async void Button_Clicked(object sender, EventArgs e) 
     { 
      //Push the page 
      var newPage = new Page2() { CoolInt = 123 }; 
      await App.Current.MainPage.Navigation.PushAsync(newPage); 

      //Await the result 
      int result = await newPage.PagePoppedTask; 
      System.Diagnostics.Debug.WriteLine("Page result: " + result.ToString()); 
     } 
    } 

    /// <summary> 
    /// Inherits from the ResultContentPage and sets the PagePoppedTask as soon as its Disappearing 
    /// </summary> 
    public class Page2 : ResultContentPage<int> 
    { 
     public int CoolInt { get; set; } //Your property on the page 

     public Page2() 
     { 
      var button = new Button() 
      { 
       Text = "Go back to page 1" 
      }; 
      button.Clicked += Button_Clicked; 

      Content = button; 
     } 

     private async void Button_Clicked(object sender, EventArgs e) 
     { 
      CoolInt = 321;          //assign dummy value to CoolInt prop and pop the page 
      await App.Current.MainPage.Navigation.PopAsync(); //pop the page 
     } 

     protected override void OnDisappearing() 
     { 
      base.OnDisappearing(); 
      SetPopupResult(CoolInt); //set the result of the task (in ResultContentPage<T>) 
     } 
    } 
} 

Answer 4

Wenn Sie nach einer idealen Lösung suchen, würde ich nach dem MVVM Muster vorschlagen und eine Menge Ihre bewegen Code von Ihrer Seite zu dem Ansichtsmodell.

Ich verwende ein MVVM-Framework namens FreshMvvm. Dies ermöglicht es mir View-Modell durchführen Modell Navigation zu sehen und wie diese Parameter zwischen ihnen passieren:

await CoreMethods.PushPageModel<BPageModel>(myParameter, true); 

Dies geht myParameter zum BPage, die ich in der Init-Methode des BPage Ansicht Modell zugreifen können.

Wenn ich Pop die B-Seite (über das View-Modell) I einen Parameter zurück auf die A-Seite übergeben kann

await CoreMethods.PopPageModel(myReturnParam, true); 

die ich in der Methode der ReverseInit APageViewModel zugreifen kann.

Die meisten MVVM-Frameworks haben ähnliche Funktionen.

Here are more details about FreshMvvm