Activer et désactiver le commutateur Xamarin Forms par MVVM

Question

J'ai 5 interrupteurs de formulaire, l'un d'entre eux est select all qui devrait sélectionner tous les autres interrupteurs à true. J'ai une logique qui veut qu'après avoir activé l'interrupteur Select All, on ne peut pas le désactiver manuellement. La seule façon de désactiver ce bouton (Select all) est de changer les autres boutons en false/Off.

J'ai géré cela à partir du modèle de vue avec une logique si mes 4 autres boutons sont vrais, je veux laisser l'utilisateur régler le bouton select all sur false par la logique get set, mais avec IOS si l'utilisateur peut forcer et maintenir le bouton sur false pendant plusieurs secondes, le bouton s'arrête sur false. J'ai essayé avec des comportements qui me donnent également les mêmes résultats. même si je peux désactiver le bouton et l'activer, cela ne me pose aucun problème, mais selon la documentation de xamarine, il n'est pas possible d'ajouter les commandes.

 bool _selectAll;

        public bool SelectAll
        {
            get
            {
                return _selectAll;
            }
            set
            {
                SetProperty(ref _selectAll, value);
                if (_activeAll && !(_button1 && _button2 && _button3 && _button4))
                {

                    Button1= true;
                    Button2= = true;
                    Button3= = true;
                    Button4= = true;
                }

                if (!_selectAll && (_emailStatus && _textStatus && _callStatus && _postStatus))
                {
                    SelectAll= true;
                }

            }
        }

Answer 1

J'ai créé un échantillon rapide en utilisant ce que j'ai pu comprendre de votre demande.

Le commutateur SelectAll activera les 4 options, mais l'utilisateur ne pourra pas désactiver le commutateur SelectAll.

J'ai fait ce qui précède en désactivant le SelectAll et de l'activer uniquement lorsque l'une des options est réglée sur faux . Pour cela, j'ai simplement lié la valeur inversée de l'élément SelectAll propriété. Pour inverser la valeur, j'ai utilisé un Converter mais il pourrait aussi être réalisé avec une autre propriété de l' ViewModel

Vérifiez si cela fonctionne pour vous.

Code :

ViewModel

public class MainViewModel : ViewModelBase
{
    private bool option1;
    public bool Option1
    {
        get => option1;
        set
        {
            if (!value) SelectAll = false;
            SetProperty(ref option1, value, nameof(Option1));
        }
    }

    private bool option2;
    public bool Option2
    {
        get => option2;
        set
        {
            if (!value) SelectAll = false;
            SetProperty(ref option2, value, nameof(Option2));
        }
    }

    private bool option3;
    public bool Option3
    {
        get => option3;
        set
        {
            if (!value) SelectAll = false;
            SetProperty(ref option3, value, nameof(Option3));
        }
    }

    private bool option4;
    public bool Option4
    {
        get => option4;
        set
        {
            if (!value) SelectAll = false;
            SetProperty(ref option4, value, nameof(Option4));
        }
    }

    private bool selectAll;
    public bool SelectAll
    {
        get => selectAll;
        set
        {
            SetProperty(ref selectAll, value, nameof(SelectAll));

            if (value)
            {
                Option1 = true;
                Option2 = true;
                Option3 = true;
                Option4 = true;
            }
        }
    }

  ....

}

Le XAML

<StackLayout Orientation="Vertical"
                Padding="20,0"
                Spacing="10"
                VerticalOptions="CenterAndExpand">

    <Switch HorizontalOptions="FillAndExpand"
            IsToggled="{Binding Option1}" />

    <Switch HorizontalOptions="FillAndExpand"
            IsToggled="{Binding Option2}" />

    <Switch HorizontalOptions="FillAndExpand"
            IsToggled="{Binding Option3}" />

    <Switch HorizontalOptions="FillAndExpand"
            IsToggled="{Binding Option4}" />

    <StackLayout Orientation="Horizontal"
                    HorizontalOptions="FillAndExpand">                         
        <Switch HorizontalOptions="Start"
                IsEnabled="{Binding SelectAll, Converter={StaticResource Invert}}"
                IsToggled="{Binding SelectAll}"
                VerticalOptions="CenterAndExpand"/>
        <Label Text="Select All"
                VerticalOptions="CenterAndExpand" />
    </StackLayout>
</StackLayout>

Mais dans le XAML vous aurez également besoin :

<ContentPage.Resources>
    <ResourceDictionary>
        <local:InvertBooleanConverter x:Key="Invert" />
    </ResourceDictionary>
</ContentPage.Resources>

Il s'agit de l'enregistrement du convertisseur.

Et le code du convertisseur :

public class InvertBooleanConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return !(bool)value;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return !(bool)value;
    }
}

Désolé d'avoir introduit le Converter dans la solution mais je crois que c'est plus propre de cette façon. Pour en savoir plus sur les convertisseurs Xamarin Forms, voir aquí .

J'espère que cela vous aidera.

Answer 2

Vous pouvez créer un Modèle comme suit :

public class ViewModel : INotifyPropertyChanged
{

    private bool swithOne;
    public bool SwithOne
    {
        set
        {
            if (swithOne != value)
            {
                swithOne = value;
                OnPropertyChanged("SwithOne");
            }
        }
        get
        {
            return swithOne;
        }
    }

    private bool swithTwo;
    public bool SwithTwo
    {
        set
        {
            if (swithTwo != value)
            {
                swithTwo = value;
                OnPropertyChanged("SwithTwo");
            }
        }
        get
        {
            return swithTwo;
        }
    }

    private bool swithThree;
    public bool SwithThree
    {
        set
        {
            if (swithThree != value)
            {
                swithThree = value;
                OnPropertyChanged("SwithThree");
            }
        }
        get
        {
            return swithThree;
        }
    }

    private bool swithFour;
    public bool SwithFour
    {
        set
        {
            if (swithFour != value)
            {
                swithFour = value;
                OnPropertyChanged("SwithFour");
            }
        }
        get
        {
            return swithFour;
        }
    }

    private bool swithFive;
    public bool SwithFive
    {
        set
        {
            if (swithFive != value)
            {
                swithFive = value;
                OnPropertyChanged("SwithFive");
                if(value == true)
                {
                    swithOne = true;
                    swithTwo = true;
                    swithThree = true;
                    swithFour = true;
                    OnPropertyChanged("SwithOne");
                    OnPropertyChanged("SwithTwo");
                    OnPropertyChanged("SwithThree");
                    OnPropertyChanged("SwithFour");
                }
                else
                {
                    swithOne = false;
                    swithTwo = false;
                    swithThree = false;
                    swithFour = false;
                    OnPropertyChanged("SwithOne");
                    OnPropertyChanged("SwithTwo");
                    OnPropertyChanged("SwithThree");
                    OnPropertyChanged("SwithFour");
                }
            }
        }
        get
        {
            return swithFive;
        }
    }

    public ViewModel()
    {
        swithOne = false;
        swithTwo = false;
        swithThree = false;
        swithFour = false;
        swithFive = false;
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Ensuite, dans XAML ajouter Switch :

<StackLayout Padding="50">
    <!-- Place new controls here -->
    <Label Text="Welcome to Xamarin.Forms!" 
       HorizontalOptions="Center"
       VerticalOptions="CenterAndExpand" />

    <Switch IsToggled="{Binding SwithOne}" HorizontalOptions="Center"/>
    <Switch IsToggled="{Binding SwithTwo}" HorizontalOptions="Center"/>
    <Switch IsToggled="{Binding SwithThree}" HorizontalOptions="Center"/>
    <Switch IsToggled="{Binding SwithFour}" HorizontalOptions="Center"/>
    <StackLayout Orientation="Vertical">
        <Label Text="Select All" HorizontalOptions="CenterAndExpand"/>
        <Switch IsToggled="{Binding SwithFive}" HorizontalOptions="Center"/>
    </StackLayout>

</StackLayout>

Enfin, en Page de contenu Modèle contraignant :

BindingContext = new ViewModel();

Voici l'effet :