App.cs

public partial class App : Application, IAppNavigationResolver {

App.ctor.cs

    public App() {
        InitializeComponent();

        var container = new UnityDependencyContainer()
            .Register<ISubViewModel, SubViewModel>()
            .Register<IMainViewModel, MainViewModel>();

        var navigationService = new NavigationService(this, container);
        container.Register<INavigationService>(navigationService);

        navigationService
            .RegisterPage<IMainViewModel, MainPage>()
            .RegisterPage<ISubViewModel, SubPage>();

        var viewModel = container.Resolve<IMainViewModel>();
        viewModel.ActivateAsync();

        MainPage = new NavigationPage(new MainPage() {
            BindingContext = viewModel
        });
    }

App.GoBackAsync.cs

public async Task<IViewModel> GoBackAsync() {
    await ((NavigationPage)this.MainPage).Navigation.PopAsync();

    var newPage = ((NavigationPage)this.MainPage).CurrentPage;
    return (IViewModel)newPage.BindingContext;
}

App.NavigateAsync.cs

public async Task NavigateAsync<TViewModel>(Type pageType, TViewModel viewModel) where TViewModel : IViewModel {
    var page = (Page)Activator.CreateInstance(pageType);
    page.BindingContext = viewModel;

    await ((NavigationPage)this.MainPage).Navigation.PushAsync(page);
}

IAppNavigationResolver.cs

public interface IAppNavigationResolver {
    Task NavigateAsync<TViewModel>(Type pageType, TViewModel viewModel)
        where TViewModel : IViewModel;
    Task<IViewModel> GoBackAsync();
}

IMainViewModel.cs

public interface IMainViewModel : IViewModel {
    ICommand SubCommand { get; }
}

INavigationService.cs

public interface INavigationService {
    INavigationService RegisterPage<TViewModel, TPage>()
        where TViewModel : IViewModel
        where TPage : new();

    Task<TViewModel> NavigateAsync<TViewModel>()
        where TViewModel : IViewModel;

    Task<IViewModel> GoBackAsync();
}

ISubViewModel.cs

public interface ISubViewModel : IViewModel {
    ICommand GoBackCommand { get; }
    String Something { get; }
    void Configure(string something);
}

IViewModel.cs

public interface IViewModel {
    Task ActivateAsync();
}

MainViewModel.cs

public class MainViewModel : IMainViewModel {
    private INavigationService navigationService;

    public ICommand SubCommand { get; }

    public MainViewModel(INavigationService navigationService) {
        this.navigationService = navigationService;
        this.SubCommand = new RelayCommand(Navigate);
    }

    private async void Navigate() {
        var viewModel = await this.navigationService.NavigateAsync<ISubViewModel>();
        viewModel.configure("This is awesome!");
    }
}

NavigationService.ctor.cs

public class NavigationService : INavigationService {
    private readonly IAppNavigationResolver appNavigationResolver;
    private readonly IDependencyContainer dependencyContainer;
    private readonly Dictionary<Type, Type> registeredPages = new Dictionary<Type, Type>();

    public NavigationService(
        IAppNavigationResolver appNavigationResolver,
        IDependencyContainer dependencyContainer
    ) {
        this.appNavigationResolver = appNavigationResolver;
        this.dependencyContainer = dependencyContainer;
    }

NavigationService.GoBackAsync.cs

    public async Task<IViewModel> GoBackAsync() {
        var viewModel = await this.appNavigationResolver.GoBackAsync();
        await viewModel.ActivateAsync();

        return viewModel;
    }

NavigationService.NavigateAsync.cs

    public async Task<TViewModel> NavigateAsync<TViewModel>()
        where TViewModel : IViewModel {
        Type pageType;
        if(!registeredPages.TryGetValue(typeof(TViewModel), out pageType)) {
            throw new InvalidOperationException($"No View registered for ViewModel type {typeof(TViewModel).Name}");
        }

        var viewModel = this.dependencyContainer.Resolve<TViewModel>();

        await viewModel.ActivateAsync();

        await this.appNavigationResolver.NavigateAsync(pageType, viewModel);
        return viewModel;
    }

NavigationService.RegisterPage.cs

    public INavigationService RegisterPage<TViewModel, TPage>()
        where TViewModel : IViewModel
        where TPage : new() {
        this.registeredPages.Add(typeof(TViewModel), typeof(TPage));

        return this;
    }
}

SubViewModel.cs

public class SubViewModel : ISubViewModel, INotifyPropertyChanged {
    public event PropertyChangedEventHandler PropertyChanged;
    private INavigationService navigationService;

    public ICommand GoBackCommand { get; }

    private string something;
    public string Something {
        get { return this.something; }
        set {
            this.something = value;
            this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(this.Something)));
        }
     }

    public SubViewModel(INavigationService navigationService) {
        this.navigationService = navigationService;
        this.GoBackCommand = new RelayCommand(NavigateBack);
    }

    public void Configure(string something) {
        this.Something = something;
    }

    private async void NavigateBack() {
        await this.navigationService.GoBackAsync();
    }
}