Xamarin iOS中ReactiveUI路由处理可行方案咨询

Great question! Routing can feel a bit ambiguous with ReactiveUI on Xamarin.iOS since the framework doesn’t force a one-size-fits-all approach, but there are several practical, idiomatic ways to handle navigation. Let’s break down your proposed approach and explore other solid options:

1. Leverage Your LoginCommand Execution Result (No Extra Property Needed) #

Your idea of using a DidLogIn boolean property is valid, but you can simplify things by directly observing the outcome of your existing LoginCommand—since it already returns a result after execution. This keeps your ViewModel clean and aligns with ReactiveUI’s reactive principles.

In your LoginViewController, update the WhenActivated block to subscribe to the command’s output:

this.WhenActivated(d => {
    // Existing bindings for Username/Password and LoginButton
    this.Bind(this.ViewModel, x => x.Username, x => x.Username.Text).DisposeWith(d);
    this.Bind(this.ViewModel, x => x.Password, x => x.Password.Text).DisposeWith(d);
    this.BindCommand(this.ViewModel, x => x.LoginCommand, x => x.LoginButton).DisposeWith(d);

    // Listen for successful login and trigger routing
    this.ViewModel.LoginCommand
        .ObserveOn(RxApp.MainThreadScheduler) // Ensure UI updates run on main thread
        .Subscribe(loginSuccess => {
            if (loginSuccess) {
                // Example: Navigate to your main view controller
                var mainVC = new MainViewController();
                NavigationController?.PushViewController(mainVC, animated: true);
            }
        })
        .DisposeWith(d);
});

This approach avoids adding unnecessary state properties to your ViewModel and uses the command’s built-in observable stream to trigger navigation.

2. View-Level Routing with a Centralized Router #

If you prefer to keep navigation logic out of your ViewModel entirely (pure view-level routing), you can create a centralized router service that your view controllers subscribe to. This helps keep navigation logic organized, especially as your app grows.

Step 1: Create a Router Service #

public class AppRouter {
    private readonly Subject<NavigationAction> _navigationRequests = new Subject<NavigationAction>();
    public IObservable<NavigationAction> NavigationRequests => _navigationRequests.AsObservable();

    // Define navigation targets
    public enum NavigationTarget { MainScreen, Settings, Profile }

    // Trigger navigation events
    public void NavigateTo(NavigationTarget target) {
        _navigationRequests.OnNext(new NavigationAction { Target = target });
    }
}

public class NavigationAction {
    public AppRouter.NavigationTarget Target { get; set; }
}

Step 2: Initialize the Router and Inject It #

In your app’s entry point (like AppDelegate), initialize the router and pass it to your view controllers:

var appRouter = new AppRouter();
var loginVC = new LoginViewController {
    ViewModel = new LoginViewModel(),
    Router = appRouter // Add a Router property to your LoginViewController
};

Step 3: Subscribe to Navigation Requests in Your View Controller #

this.WhenActivated(d => {
    // Existing bindings...

    // Listen for router navigation requests
    Router.NavigationRequests
        .ObserveOn(RxApp.MainThreadScheduler)
        .Subscribe(action => {
            switch (action.Target) {
                case AppRouter.NavigationTarget.MainScreen:
                    var mainVC = new MainViewController { Router = Router };
                    NavigationController?.PushViewController(mainVC, animated: true);
                    break;
                // Handle other targets as needed
            }
        })
        .DisposeWith(d);

    // Bind LoginCommand to trigger router navigation
    this.ViewModel.LoginCommand
        .Subscribe(_ => Router.NavigateTo(AppRouter.NavigationTarget.MainScreen))
        .DisposeWith(d);
});

This approach keeps your ViewModel focused on business logic, while navigation is managed by the view layer via the router.

3. Platform-Agnostic ViewModel-Driven Routing (For Testability) #

If you want your ViewModel to drive navigation without tying it to Xamarin.iOS-specific UIKit code, you can use a dependency-injected navigation service. This makes your ViewModel testable (you can mock the service in unit tests) and keeps it platform-independent.

Step 1: Define a Navigation Service Interface #

public interface INavigationService {
    Task NavigateToMainAsync();
    // Add other navigation methods as needed
}

Step 2: Implement the iOS-Specific Service #

public class iOSNavigationService : INavigationService {
    private readonly UINavigationController _navigationController;

    public iOSNavigationService(UINavigationController navigationController) {
        _navigationController = navigationController;
    }

    public async Task NavigateToMainAsync() {
        var mainVC = new MainViewController();
        _navigationController.PushViewController(mainVC, animated: true);
        await Task.CompletedTask;
    }
}

Step 3: Inject the Service into Your ViewModel #

public class LoginViewModel : ReactiveObject {
    private readonly ReactiveCommand loginCommand;
    private readonly INavigationService _navigationService;

    public ReactiveCommand LoginCommand => loginCommand;

    // Username/Password properties...

    public LoginViewModel(INavigationService navigationService) {
        _navigationService = navigationService;

        var canLogin = this.WhenAnyValue(
            x => x.Username,
            x => x.Password,
            (u, p) => !string.IsNullOrEmpty(u) && !string.IsNullOrEmpty(p)
        );

        loginCommand = ReactiveCommand.CreateFromTask(async () => {
            await Task.Delay(2000); // Simulate login
            await _navigationService.NavigateToMainAsync(); // Trigger navigation from VM
            return true;
        }, canLogin);
    }
}

Step 4: Initialize the Service in Your App #

var navigationController = new UINavigationController();
var navigationService = new iOSNavigationService(navigationController);
var loginVM = new LoginViewModel(navigationService);
var loginVC = new LoginViewController { ViewModel = loginVM };
navigationController.PushViewController(loginVC, animated: false);

This approach is ideal for larger apps where testability and separation of concerns are priorities.

Which Approach Should You Choose? #

• Simple apps: Go with observing the LoginCommand result—it’s quick and requires minimal setup.
• Medium apps: Use the centralized router to keep navigation logic organized and separated from business logic.
• Large/testable apps: Use the platform-agnostic navigation service to keep ViewModels independent of iOS code and easy to test.

内容的提问来源于stack exchange，提问作者RVandersteen