Désactiver ToolbarItem Xamarin.Forms

J'ai le texte suivant dans ma page:

<ContentPage.ToolbarItems>
    <ToolbarItem Text="Run" Command="{Binding RunCommand}" />
</ContentPage.ToolbarItems>

La commande démarre une tâche asynchrone.
Je suis en train d'essayer de désactiver le contrôle tant que la tâche asynchrone est toujours en cours d'exécution en la liant à une propriété booléenne comme suit:

<ContentPage.ToolbarItems>
    <ToolbarItem Text="Run" Command="{Binding RunCommand}" IsEnabled="{Binding MyBoolProperty}" />
</ContentPage.ToolbarItems>

Mon problème est qu'il ne semble pas être un "IsEnabled de la propriété" pour ToolbarItem. Est-il un moyen de réaliser ce que je suis en train de faire à l'aide de Xamarin.Les formes?

source d'informationauteur LostBalloon

  1. 16

    Après l'aide de William et Xamarin de soutien, j'ai enfin réussi à trouver comment fonctionne de la fonctionnalité.

    C'est un peu contre-intuitif car on s'attend d'Activer/Désactiver le bouton (ToolbarItem), mais en réalité, nous avons à gérer l'état de la commande qui est lié à la touche. Une fois que nous comprenons ce modèle, c'est logique.

    L'objet de Commande de type ICommand, a une propriété CanExecute (merci William pour le pointage)
    Maintenant, vous ne voulez pas d'avoir accès directement, sauf si c'est pour vérifier effectivement si la commande peut être exécutée ou non.

    Où bon vous semble dans votre code, pour changer l'état de la commande, vous devez ajouter la ligne suivante:

    ((Command)_myCommand).ChangeCanExecute();

    Cette ligne de force de la propriété CanExecute d'être ré-évalué pour la commande spécifiée.

    Personnellement, j'ai décidé de l'ajouter, où j'ai suivi l'inactivité, comme il fait sens dans mon application.

    public bool Inactive { 
    get { 
        return _inactive;
    } 
    set {
        if (_inactive != value) {
            _inactive = value;
            ((Command)_myCommand).ChangeCanExecute();
            OnPropertyChanged ();
        }
    }
}

    Dans la Vue, il n'y a pas de changements à noter:

    <ToolbarItem Text="Run" Command="{Binding MyCommand}" />

    Maintenant, lorsque vous créez l'objet de Commande est où le gros du travail sera fait. Nous utilisons généralement le seul argument constructeur, car il est généralement assez et c'est là que nous définissons ce que notre commande. Fait intéressant, il est de 2 constructeur de paramètre ainsi où vous pouvez fournir la fonction/action qui détermine la valeur de la propriété CanExecute.

    _myCommand = new Command (async () => {
                                          Inactive = false;
                                          await Run();
                                          Inactive = true;
                                      },
                                      () => {
                                          return Inactive;
                                      });


public ICommand MyCommand {
    get { 
        return _myCommand;
    }
}

    Edit: je sais que vous que, techniquement, la modification de la valeur des Inactifs qui devrait arriver dans Run(), mais pour les besoins de la démonstration...

  2. 1

    Ce que j'ai appris à faire dans ces situations est comme suit:

    public Command RunCommand 
{ 
    get { return new Command(async() => await OnRunCommand()); }
}    

private bool _isRunning;

public async Task OnRunCommand() 
{
    if (_isRunning) return;
    _isRunning = true;

    //do stuff

    _isRunning = false;
}

    La inconvénient: cela laisse à l'élément de barre d'outils dans son état normal et les utilisateurs peuvent continuer à toucher.

    La à l'envers: ce ne sera pas permettre à simultanée OnRunCommand tâches, ce qui est bon.

    Si vous souhaitez poursuivre la désactivation du bouton en montrant un handicapé de l'image, vous devez créer un moteur de rendu.

    Si vous ne voulez pas afficher la barre d'outils, tandis que la tâche est en cours d'exécution, envisager de supprimer la barre d'outils de la page et de le rajouter plus tard.

  3. 1

    Cet exemple est à retirer, ne désactivez pas, mais peut également être à portée de main.

        ToolbarItem delToolbar;       

    ...

        delToolbar = new ToolbarItem
        {
            Order = ToolbarItemOrder.Primary,                
            Text = "delete",              
            Command = new Command(async () =>
            {                                       
                ToolbarItems.Remove(delToolbar);
            })
        };
        ToolbarItems.Add(delToolbar);