ListView SelectedItem与TextCell Command的区别及Xamarin MVVM更新方案问询

Hey there! Let's break this down step by step since you're working with Xamarin.Forms MVVM and trying to update an external Label based on a selected TextCell.

These two serve distinct purposes in Xamarin.Forms, so let's clarify:

• ListView.SelectedItem: This is a property of the ListView itself, designed to track the currently selected list item (regardless of the Cell type used). It's built for state tracking—when a user taps any Cell, this property automatically updates to the bound object, and vice versa (if you update the ViewModel property, the ListView will select the corresponding item). It’s ideal if you need to maintain or reference the selected state elsewhere in your logic.
• TextCell.Command: This is a Cell-level interaction trigger. It’s tied directly to a single TextCell, and fires a bound command when that specific Cell is tapped. You can pass the Cell’s bound object via CommandParameter to act on it immediately. This is more about action execution rather than tracking a persistent selected state.

Let’s cover both approaches, plus the optimized version of your initial idea.

Option 1: Two-Way Bind SelectedItem (Your Initial Idea, Polished) #

This is great if you need to track the selected state for other uses (like highlighting the selected Cell or reusing the selected item later).

1. ViewModel Setup
   First, make your ViewModel inherit from a base class that implements INotifyPropertyChanged (to notify the UI of property updates). Here’s a minimal base class example:

   public class BaseViewModel : INotifyPropertyChanged
   {
       public event PropertyChangedEventHandler PropertyChanged;
   
       protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
       {
           PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
       }
   
       protected bool SetProperty<T>(ref T backingStore, T value, [CallerMemberName] string propertyName = null)
       {
           if (EqualityComparer<T>.Default.Equals(backingStore, value)) return false;
           backingStore = value;
           OnPropertyChanged(propertyName);
           return true;
       }
   }
   

   Then, in your ViewModel:

   public class YourViewModel : BaseViewModel
   {
       private YourItemType _selectedListItem;
       private string _labelText;
   
       // Your list of items to display in ListView
       public ObservableCollection<YourItemType> ItemList { get; set; }
   
       // Bound to ListView.SelectedItem
       public YourItemType SelectedListItem
       {
           get => _selectedListItem;
           set
           {
               if (SetProperty(ref _selectedListItem, value))
               {
                   // Update the Label's bound property when selection changes
                   LabelText = value?.YourTextProperty ?? string.Empty;
               }
           }
       }
   
       // Bound to the external Label
       public string LabelText
       {
           get => _labelText;
           set => SetProperty(ref _labelText, value);
       }
   
       // Constructor to initialize data
       public YourViewModel()
       {
           ItemList = new ObservableCollection<YourItemType>(/* Your data here */);
       }
   }
   

2. XAML Binding

   <!-- Assume your page's BindingContext is set to YourViewModel -->
   <ListView ItemsSource="{Binding ItemList}" 
             SelectedItem="{Binding SelectedListItem, Mode=TwoWay}">
       <ListView.ItemTemplate>
           <DataTemplate>
               <TextCell Text="{Binding YourTextProperty}" />
           </DataTemplate>
       </ListView.ItemTemplate>
   </ListView>
   
   <!-- External Label bound to the updated property -->
   <Label Text="{Binding LabelText}" 
          HorizontalOptions="Center" 
          Margin="0,10" />
   

Option 2: Use TextCell.Command (No Selected State Tracking) #

If you don’t need to maintain the selected state and just want to update the Label on tap, this is a more direct approach.

1. ViewModel Setup
   Add a command to handle the Cell tap:

   public class YourViewModel : BaseViewModel
   {
       public ObservableCollection<YourItemType> ItemList { get; set; }
       public string LabelText { get; set; } // Same as before
       public ICommand CellTappedCommand { get; }
   
       public YourViewModel()
       {
           ItemList = new ObservableCollection<YourItemType>(/* Your data here */);
           CellTappedCommand = new Command<YourItemType>(OnCellTapped);
       }
   
       private void OnCellTapped(YourItemType tappedItem)
       {
           if (tappedItem != null)
               LabelText = tappedItem.YourTextProperty;
       }
   }
   

2. XAML Binding
   Since the TextCell’s BindingContext is the individual list item, we need to reference the page’s ViewModel to access the command:

   <!-- Give your page a name to reference -->
   <ContentPage x:Name="MainPage" ...>
       <ListView ItemsSource="{Binding ItemList}">
           <ListView.ItemTemplate>
               <DataTemplate>
                   <TextCell Text="{Binding YourTextProperty}"
                             Command="{Binding BindingContext.CellTappedCommand, Source={x:Reference MainPage}}"
                             CommandParameter="{Binding .}" />
               </DataTemplate>
           </ListView.ItemTemplate>
       </ListView>
   
       <Label Text="{Binding LabelText}" ... />
   </ContentPage>
   

• Go with SelectedItem binding if you need to keep track of the selected item (e.g., for highlighting, editing, or reusing the selection later).
• Use TextCell.Command if you only need to trigger a one-time action (like updating the Label) without maintaining the selected state.

内容的提问来源于stack exchange，提问作者S1r-Lanzelot