Xamarin.Forms => Navigation in Xamarin.Forms

Bemerkungen

Die Navigation auf Xamarin.Forms basiert auf zwei Hauptnavigationsmustern: hierarchisch und modal.

Das hierarchische Muster ermöglicht es dem Benutzer, sich in einem Stapel von Seiten nach unten zu bewegen und durch Drücken der Taste "Zurück" / "Hoch" zurückzukehren.

Das modale Muster ist eine Unterbrechungsseite, die vom Benutzer eine bestimmte Aktion erfordert, die aber normalerweise durch Drücken der Abbruchtaste abgebrochen werden kann. Beispiele sind Benachrichtigungen, Alarme, Dialogfelder und Register / Editionsseiten.

Verwendung von INavigation aus dem Ansichtsmodell

Der erste Schritt ist das Erstellen einer Navigationsschnittstelle, die wir für das Ansichtsmodell verwenden werden:

public interface IViewNavigationService
{
    void Initialize(INavigation navigation, SuperMapper navigationMapper);
    Task NavigateToAsync(object navigationSource, object parameter = null);
    Task GoBackAsync();
}

Bei der Initialize verwende ich meinen benutzerdefinierten Mapper, bei dem ich die Seitentypen mit den zugehörigen Schlüsseln sammle.

public class SuperMapper
{
    private readonly ConcurrentDictionary<Type, object> _typeToAssociateDictionary = new ConcurrentDictionary<Type, object>();

    private readonly ConcurrentDictionary<object, Type> _associateToType = new ConcurrentDictionary<object, Type>();

    public void AddMapping(Type type, object associatedSource)
    {
        _typeToAssociateDictionary.TryAdd(type, associatedSource);
        _associateToType.TryAdd(associatedSource, type);
    }

    public Type GetTypeSource(object associatedSource)
    {
        Type typeSource;
        _associateToType.TryGetValue(associatedSource, out typeSource);

        return typeSource;
    }

    public object GetAssociatedSource(Type typeSource)
    {
        object associatedSource;
        _typeToAssociateDictionary.TryGetValue(typeSource, out associatedSource);

        return associatedSource;
    }
}

Aufzählung mit Seiten:

public enum NavigationPageSource
{
    Page1,
    Page2
}

App.cs Datei:

public class App : Application
{
    public App()
    {
        var startPage = new Page1();
        InitializeNavigation(startPage);
        MainPage = new NavigationPage(startPage);
    }

    #region Sample of navigation initialization
    private void InitializeNavigation(Page startPage)
    {
        var mapper = new SuperMapper();
        mapper.AddMapping(typeof(Page1), NavigationPageSource.Page1);
        mapper.AddMapping(typeof(Page2), NavigationPageSource.Page2);

        var navigationService = DependencyService.Get<IViewNavigationService>();
        navigationService.Initialize(startPage.Navigation, mapper);
    } 
    #endregion
}

In Mapper verknüpfte ich den Typ einer Seite mit dem Aufzählungswert.

IViewNavigationService Implementierung:

[assembly: Dependency(typeof(ViewNavigationService))]
namespace SuperForms.Core.ViewNavigation
{
    public class ViewNavigationService : IViewNavigationService
    {
        private INavigation _navigation;
        private SuperMapper _navigationMapper;

        public void Initialize(INavigation navigation, SuperMapper navigationMapper)
        {
            _navigation = navigation;
            _navigationMapper = navigationMapper;
        }

        public async Task NavigateToAsync(object navigationSource, object parameter = null)
        {
            CheckIsInitialized();

            var type = _navigationMapper.GetTypeSource(navigationSource);

            if (type == null)
            {
                throw new InvalidOperationException(
                    "Can't find associated type for " + navigationSource.ToString());
            }

            ConstructorInfo constructor;
            object[] parameters;

            if (parameter == null)
            {
                constructor = type.GetTypeInfo()
                                  .DeclaredConstructors
                                  .FirstOrDefault(c => !c.GetParameters().Any());

                parameters = new object[] { };
            }
            else
            {
                constructor = type.GetTypeInfo()
                                  .DeclaredConstructors
                                  .FirstOrDefault(c =>
                                    {
                                        var p = c.GetParameters();
                                        return p.Count() == 1 &&
                                            p[0].ParameterType == parameter.GetType();
                                    });

                parameters = new[] { parameter };
            }

            if (constructor == null)
            {
                throw new InvalidOperationException(
                    "No suitable constructor found for page " + navigationSource.ToString());
            }

            var page = constructor.Invoke(parameters) as Page;

            await _navigation.PushAsync(page);
        }

        public async Task GoBackAsync()
        {
            CheckIsInitialized();

            await _navigation.PopAsync();
        }

        private void CheckIsInitialized()
        {
            if (_navigation == null || _navigationMapper == null)
                throw new NullReferenceException("Call Initialize method first.");
        }
    }
}

Ich bekomme den Seitentyp, auf dem der Benutzer navigieren möchte, und erzeuge dessen Instanz mithilfe von Reflektion.

Und dann könnte ich den Navigationsdienst für das Ansichtsmodell verwenden:

var navigationService = DependencyService.Get<IViewNavigationService>();
await navigationService.NavigateToAsync(NavigationPageSource.Page2, "hello from Page1");

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

Xamarin.Forms
Navigation in Xamarin.Forms

Suche…

Bemerkungen

Verwendung von INavigation aus dem Ansichtsmodell