Interaction.Behaviors, EventTriggerBehavior-Befehl wird nicht aufgerufen

Question

Unten ist Onload-Ereignis-Trigger von meiner XAML-Ansicht.

<interactivity:Interaction.Behaviors> 
    <core:EventTriggerBehavior EventName="Loaded"> 
     <core:EventTriggerBehavior.Actions> 
      <core:InvokeCommandAction Command="{Binding LoadedCommand}" /> 
     </core:EventTriggerBehavior.Actions> 
    </core:EventTriggerBehavior> 
</interactivity:Interaction.Behaviors> 
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
    <Grid.RowDefinitions> 
     <RowDefinition Height="*" /> 
     <RowDefinition Height="100" /> 
    </Grid.RowDefinitions> 
    <GridView ItemsSource="{Binding Appointments}" IsItemClickEnabled="True"> 
     <GridView.ItemTemplate> 
      <DataTemplate x:DataType="vm:Appointment"> 
       <StackPanel Orientation="Vertical" HorizontalAlignment="Center"> 
        <StackPanel Margin="20,20,0,0"> 
         <TextBlock FontSize="18" Text="{x:Bind Name}" VerticalAlignment="Bottom"></TextBlock> 
         <TextBlock FontSize="10" Text="{x:Bind Category }" VerticalAlignment="Bottom"></TextBlock> 
        </StackPanel> 
       </StackPanel> 
      </DataTemplate> 
     </GridView.ItemTemplate> 
    </GridView> 
    <TextBlock Grid.Row="1" Name="ResultTextBlock" FontSize="24" Foreground="Red" FontWeight="Bold" /> 
</Grid> 

Befehlsimplementierung hier.

public class DelegateCommand : ICommand 
{ 
    private readonly Predicate<object> _canExecute; 
    private readonly Action<object> _execute; 

    public event EventHandler CanExecuteChanged; 

    public DelegateCommand(Action<object> execute) 
       : this(execute, null) 
    { 
    } 

    public DelegateCommand(Action<object> execute, 
       Predicate<object> canExecute) 
    { 
     _execute = execute; 
     _canExecute = canExecute; 
    } 


    public void RaiseCanExecuteChanged() 
    { 
     if (CanExecuteChanged != null) 
     { 
      CanExecuteChanged(this, EventArgs.Empty); 
     } 
    } 

    public bool CanExecute(object parameter) 
    { 
     if (_canExecute == null) 
     { 
      return true; 
     } 

     return _canExecute(parameter); 
    } 

    public void Execute(object parameter) 
    { 
     _execute(parameter); 
    } 

} 

Befehl wird nicht ausgeführt. Danke für die Hilfe im Voraus.

Ich habe versucht, das Viewmodel wie this.View Modell der Onload Befehl hat, die die asychronous Methode ExecuteLoadedCommandAsync nennt das Ergebnis, es zu

public class AppointmentViewModel : ViewModelbase 
{  
    public List<Appointment> Appointments { get; set; } 

    public DelegateCommand LoadedCommand { get; } 

    public AppointmentViewModel() 
    { 
     LoadedCommand = new DelegateCommand(async (param) => await ExecuteLoadedCommandAsync()); 
    } 

    public async Task ExecuteLoadedCommandAsync() 
    { 
     Appointments = await AppointmentService.GetAppointments(); 
    }  
}  

Noch hat nicht funktioniert.

Answer 1

Ich habe das obige Code-Snippet getestet. Tatsächlich wird die ExecuteLoadedCommandAsync() ausgeführt. Mit dem Befehl InvokeCommandAction ist nichts falsch. Hinzufügen eines Knickpunktes bei ExecuteLoadedCommandAsync() Methode, um dies zu testen. Die Appointments Datensätze können nicht in die Ansicht geladen werden. Dies liegt daran, dass der Wert Appointments null ist, wenn das Ansichtsmodell neu instanziiert wird, und der Wert wird nach dem Ereignis loaded festgelegt. Also für dynamische geänderte Eigenschaft müssen Sie I​Notify​Property​Changed für Appointments Eigenschaft implementieren, wie folgt:

public class AppointmentViewModel : INotifyPropertyChanged 
{ 
    //public List<Appointment> Appointments { get; set; } 
    private List<Appointment> appointments; 
    public List<Appointment> Appointments 
    { 
     get 
     { 
      return appointments; 
     } 
     set 
     { 
      if (appointments != value) 
      { 
       appointments = value; 
       OnPropertyChanged("Appointments"); 
      } 
     } 
    } 

    public DelegateCommand LoadedCommand { get; } 

    public AppointmentViewModel() 
    {   
     LoadedCommand = new DelegateCommand((param) => ExecuteLoadedCommand()); 
    } 

    public void ExecuteLoadedCommand() 
    { 
     Appointments = GetAppointments(); 
    } 

    public List<Appointment> GetAppointments() 
    { 
     List<Appointment> allappointments = new List<Appointment>(); 
     allappointments.Add(new Appointment() { Name = "name1", Category = "category1" }); 
     allappointments.Add(new Appointment() { Name = "name2", Category = "category4" }); 
     allappointments.Add(new Appointment() { Name = "name3", Category = "category3" }); 
     return allappointments; 
    } 
    #region INotifyPropertyChanged 
    public event PropertyChangedEventHandler PropertyChanged; 

    private void OnPropertyChanged(string propertyName) 
    { 
     if (PropertyChanged != null) 
     { 
      PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); 
     } 
    } 
    #endregion 
} 

-Code hinter der XAML-Ansicht:

public MainPage() 
{ 
    this.InitializeComponent(); 
    AppointmentViewModel vm = new AppointmentViewModel(); 
    this.DataContext = vm; 
} 

Weitere Informationen erhalten Sie verweisen Data binding in depth.