Binding not working when modifying ObservableCollection

Question

I am trying to bind RadioButton to an ObservableCollection<Face>. I already made several bindings, and they are all working. But on that one, I cannot understand what is going wrong.The only thing that differs that time, is I tried to use a converter for that. First, my ObservableCollection was an ObservableCollection<int>, then I change it to an ObservableCollection<Face>, because I believed the problem was I cannot bind on an ObservableCollection<int>, but nothing changed.

Here is my converter. I would like not to have a ConvertBack, but cannot remove it? :

public class VisibleIfListIntContains : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        if (parameter == null)
        {
            return false;
        }
        ObservableCollection<int> listInt = (ObservableCollection<int>)value;
        int value2 = System.Convert.ToInt32(parameter.ToString());
        //bool? retour = listInt.Contains(value2);
        return listInt.Contains(value2)
            ? Visibility.Visible
            : Visibility.Collapsed;
    }
    public object ConvertBack(object value, Type targetTypes, object parameter, System.Globalization.CultureInfo culture)
    {
        if ((bool)value == true)
        {
            return System.Convert.ToInt32(parameter);
        }
        else
        {
            return new List<int>();
        }
    }
}

Then the class on which I am binding :

public partial class Macro : INotifyPropertyChanged
{
    private ObservableCollection<int> listFacesAllowed = new ObservableCollection<int>();
    public ObservableCollection<int> ListFacesAllowed
    {
        get { return this.listFacesAllowed; }
        set
        {
            this.listFacesAllowed = value;
            this.NotifyPropertyChanged("ListFacesAllowed");
        }
    }
}

I modify my ObservableCollection this way :

private void setAvailableFaces()
{
    this.ListFacesAllowed.Clear();
    if (this.gpProfil == "I" || this.gpProfil == "H" || this.gpProfil == "U")
    {
        this.ListFacesAllowed.Add(0);
        this.ListFacesAllowed.Add(1);
        this.ListFacesAllowed.Add(2);
    }
    else if (this.gpProfil == "L")
    {
        this.ListFacesAllowed.Add(0);
        this.ListFacesAllowed.Add(2);
    }
    else if (this.gpProfil == "M")
    {
        this.ListFacesAllowed.Add(0);
        this.ListFacesAllowed.Add(1);
        this.ListFacesAllowed.Add(2);
        this.ListFacesAllowed.Add(3);
    }
    if (this.type==1)
    {
        if (this.isTraversingMacro)
        {
            if (this.gpProfil == "M")
            {
                this.ListFacesAllowed.Remove(1);
                this.ListFacesAllowed.Remove(3);
            }
            else if (gpProfil == "I" || gpProfil == "H" || gpProfil == "U")
            {
                this.ListFacesAllowed.Remove(1);
                if (this.name != "MV002" && this.name != "MV000")
                {
                    this.ListFacesAllowed.Remove(2);
                }
            }

        }
    }
    this.NotifyPropertyChanged("ListFacesAllowed");
    if (this.listFacesAllowed.Any() && !this.listFacesAllowed.Contains(this.face))
    {
        this.Face = this.listFacesAllowed[0];
    }
}

The ObservableCollection is modified, but the converter is never executed.

Here is XAML code :

<DataTemplate x:Key="TemplateType1">
        <Grid Background="{StaticResource WindowBackgroundColor}">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="auto"/>
                <ColumnDefinition Width="auto"/>
                <ColumnDefinition Width="200"/>
            </Grid.ColumnDefinitions>
            <Grid Margin="10,10,20,10">
                <Grid.RowDefinitions>
                    <RowDefinition Height="auto"/>
                    <RowDefinition Height="auto"/>
                    <RowDefinition Height="auto"/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="100"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                <Grid Grid.RowSpan="2">
                    <Grid.RowDefinitions>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="auto"/>
                    </Grid.RowDefinitions>
                    <ListView ItemsSource="{Binding}" SelectedItem="{Binding DataContext.SelectedMacro,   
                        RelativeSource={RelativeSource AncestorType=Window},Mode=TwoWay}"  Margin="3" Width="auto">
                        <ListView.View>
                            <GridView>
                                <GridViewColumn Header="{x:Static p:Resources.Name}" Width="auto" DisplayMemberBinding="{Binding Name}"/>
                            </GridView>
                        </ListView.View>
                    </ListView>
                    <Button Grid.Row="1" HorizontalAlignment="Left" Margin="3,10,3,3" Click="AddMacro_Click">
                        <Image Source="../img/image_add.png" Width="40"/>
                    </Button>
                </Grid>

                <Grid Grid.Column="1">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="auto"/>
                        <ColumnDefinition Width="*"/>
                        <ColumnDefinition Width="auto"/>
                    </Grid.ColumnDefinitions>
                    <Grid Grid.Column="0">
                        <Grid.RowDefinitions>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="20"/>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="*"/>
                        </Grid.RowDefinitions>
                        <CheckBox Grid.Row="0" IsChecked="{Binding DataContext.SelectedMacro.IsTraversingMacro, RelativeSource={RelativeSource AncestorType=Window},Mode=TwoWay}" 
                                    Content="{x:Static p:Resources.Traversing}"
                                    Margin="3"/>

                        <RadioButton Grid.Row="2" IsChecked="{Binding DataContext.SelectedMacro.Face, RelativeSource={RelativeSource AncestorType=Window},Converter={StaticResource isIntEqual},ConverterParameter=0}" 
                                    Visibility="{Binding DataContext.SelectedMacro.ListFacesAllowed, RelativeSource={RelativeSource AncestorType=Window},Converter={StaticResource visibleIfListIntContains},ConverterParameter=0}"
                                    Content="{x:Static p:Resources.Web}"
                                    Margin="3"/>
                        <RadioButton Grid.Row="3" IsChecked="{Binding DataContext.SelectedMacro.Face, RelativeSource={RelativeSource AncestorType=Window},Converter={StaticResource isIntEqual},ConverterParameter=1}" 
                                    Visibility="{Binding DataContext.SelectedMacro.ListFacesAllowed, RelativeSource={RelativeSource AncestorType=Window},Converter={StaticResource visibleIfListIntContains},ConverterParameter=1}"
                                    Content="{x:Static p:Resources.FlangeTop}"
                                    Margin="3"/>
                        <RadioButton Grid.Row="4" IsChecked="{Binding DataContext.SelectedMacro.Face, RelativeSource={RelativeSource AncestorType=Window},Converter={StaticResource isIntEqual},ConverterParameter=2}" 
                                    Visibility="{Binding DataContext.SelectedMacro.ListFacesAllowed, RelativeSource={RelativeSource AncestorType=Window},Converter={StaticResource visibleIfListIntContains},ConverterParameter=2}"
                                    Content="{x:Static p:Resources.FlangeBottom}"
                                    Margin="3"/>
                        <RadioButton Grid.Row="5" IsChecked="{Binding DataContext.SelectedMacro.Face, RelativeSource={RelativeSource AncestorType=Window},Converter={StaticResource isIntEqual},ConverterParameter=3}" 
                                    Visibility="{Binding DataContext.SelectedMacro.ListFacesAllowed, RelativeSource={RelativeSource AncestorType=Window},Converter={StaticResource visibleIfListIntContains},ConverterParameter=3}"
                                    Content="{x:Static p:Resources.WebBack}"
                                    Margin="3"/>
                    </Grid>
                    <Grid Grid.Column="2" HorizontalAlignment="Right">
                        <Grid.RowDefinitions>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="*"/>

                        </Grid.RowDefinitions>
                        <RadioButton Visibility="{Binding DataContext.SelectedMacro.BottomChoice,   
                        RelativeSource={RelativeSource AncestorType=Window}, Converter={StaticResource BoolToVisConverter}}"
                        Content="{x:Static p:Resources.Top}"
                        GroupName="radioGroup31" Margin="0,3,0,3"
                        IsChecked="{Binding DataContext.SelectedMacro.Bottom,   
                        RelativeSource={RelativeSource AncestorType=Window},
                                            Converter={StaticResource InverseBoolRadioConverter}}" />
                        <RadioButton Grid.Row="1" Visibility="{Binding DataContext.SelectedMacro.BottomChoice,   
                        RelativeSource={RelativeSource AncestorType=Window}, Converter={StaticResource BoolToVisConverter}}"
                        Content="{x:Static p:Resources.Bottom}"
                        GroupName="radioGroup32" Margin="0,3,0,3"
                        IsChecked="{Binding DataContext.SelectedMacro.Bottom,   
                        RelativeSource={RelativeSource AncestorType=Window}, Converter={StaticResource BoolRadioConverter}}" />
                    </Grid>

                </Grid>
                <Grid Grid.Column="1" Grid.Row="1">
                    <Grid.RowDefinitions>
                        <RowDefinition Height="auto"/>
                        <RowDefinition Height="auto"/>
                    </Grid.RowDefinitions>
                    <Label Content="{Binding DataContext.SelectedMacro.Name,   
                        RelativeSource={RelativeSource AncestorType=Window}}" HorizontalAlignment="Center" FontSize="30"/>
                    <Image Grid.Row="1" Width="250" Height="250" Source="{Binding DataContext.SelectedMacro.ImageName,   
                        RelativeSource={RelativeSource AncestorType=Window}}"/>
                </Grid>
                <Grid Grid.Row="2" Grid.Column="1">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="80"/>
                        <ColumnDefinition Width="*"/>
                        <ColumnDefinition Width="80"/>
                    </Grid.ColumnDefinitions>
                    <Button Content="{x:Static p:Resources.Delete}" Click="DeleteMacro_Click" Margin="3" >
                        <Button.Style>
                            <Style TargetType="Button" BasedOn="{StaticResource {x:Type Button}}">
                                <Style.Triggers>
                                    <DataTrigger Binding="{Binding DataContext.SelectedMacro.Name,RelativeSource={RelativeSource AncestorType=Window}, Mode=OneWay}" Value="">
                                        <Setter Property="Button.IsEnabled" Value="False" />
                                    </DataTrigger>
                                </Style.Triggers>
                            </Style>
                        </Button.Style>
                    </Button>
                    <Button Content="{x:Static p:Resources.Change}" Grid.Column="2" Click="EditMacro_Click" Margin="3">
                        <Button.Style>
                            <Style TargetType="Button" BasedOn="{StaticResource {x:Type Button}}">
                                <Style.Triggers>
                                    <DataTrigger Binding="{Binding DataContext.SelectedMacro.Name,RelativeSource={RelativeSource AncestorType=Window}, Mode=OneWay}" Value="">
                                        <Setter Property="Button.Content" Value="{x:Static p:Resources.Add}" />
                                    </DataTrigger>
                                </Style.Triggers>
                            </Style>
                        </Button.Style>
                    </Button>
                </Grid>

            </Grid>
            <Grid Margin="20,10,10,10" Grid.Column="2">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="auto"/>
                    <ColumnDefinition Width="auto"/>
                </Grid.ColumnDefinitions>
                <ItemsControl Grid.Column="0" ItemsSource="{Binding DataContext.SelectedMacro.ListParams,RelativeSource={RelativeSource AncestorType=Window}}">
                    <ItemsControl.ItemTemplate>
                        <DataTemplate>
                            <Grid Margin="0,0,0,5" Height="30">
                                <Grid.ColumnDefinitions>
                                    <ColumnDefinition Width="auto" />
                                </Grid.ColumnDefinitions>
                                <Label Content="{Binding Name}" VerticalAlignment="Center"/>
                            </Grid>
                        </DataTemplate>
                    </ItemsControl.ItemTemplate>
                </ItemsControl>
                <ItemsControl Grid.Column="1" ItemsSource="{Binding DataContext.SelectedMacro.ListParams,RelativeSource={RelativeSource AncestorType=Window}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
                    <ItemsControl.ItemTemplate>
                        <DataTemplate>
                            <Grid Margin="0,0,0,5" Height="30">
                                <Grid.ColumnDefinitions>
                                    <ColumnDefinition Width="100" />
                                </Grid.ColumnDefinitions>
                                <TextBox Grid.Column="1" Text="{Binding Valeur}" PreviewTextInput="CheckIsPositiveDouble" VerticalAlignment="Center" />
                            </Grid>
                        </DataTemplate>
                    </ItemsControl.ItemTemplate>
                </ItemsControl>
            </Grid>
        </Grid>
    </DataTemplate>

All bindings in the template work good, except the ones for DataContext.SelectedMacro.ListFacesAllowed

I believe `ICollection.Add()` will not call your setter function inside the property. Can you try `NotifyPropertyChanged` explicitly after `.Add` in the `foreach` loop. — shruti singh, Oct 14 '22 at 07:31
@shrutisingh in fact, adding the `NotifyPropertyChanged` solved the problem. Could you explain why in this case I need to do that? I never add it when binding an `ObservableCollection`. (If you could explain it as an answer so I could close the question, thanks) — Siegfried.V, Oct 14 '22 at 07:35
You should always implement inotifypropertychanged on any viewmodel. Unless you like memory leaks. — Andy, Oct 14 '22 at 08:42
The reason for the difference in this instance is you're changing a property. Observablecollection notifies for collection change. Add or delete of items in the collection. You can also substitute an item and it notifies for item change. But this is an entire item rather than a property changing. — Andy, Oct 14 '22 at 08:45
All this is wpf basics. You should buy a book and read the documentation. — Andy, Oct 14 '22 at 08:46
@Andy I did implement `NotifyPropertyChanged` on my ObservableCollection. But why in that case I need to call it explicitly? Usualy when I bind (i.e. a ListView) to an ObservableCollection, I can Add/Remove items without doing it, the `NotifyPropertyChanged` is called automaticaly, isn't it? — Siegfried.V, Oct 14 '22 at 08:59
Apologies for late response. I see that the answer is already accepted. However, adding this comment to answer your doubt above. Think of it in a way, that `NotifyPropertyChanged` is called explicitly from the setter. Does the setter get called when you modify (add/remove items) the collection? No. The setter will be called when you do `collection = new Collection()`. Ideally, `NotifyPropertyChanged` must be called everytime when the underlying property changes. — shruti singh, Dec 23 '22 at 11:44

EldHasp · Accepted Answer · 2022-10-16T07:16:50.757

As far as I understand, you need to check for the presence of UI element Id in the Id collection. And if it is there, then install its Visibility.

If I understood this correctly, then the obvious problem is that you misunderstand the logic of Binding.
The binding will work on the first load, and for subsequent updates, you need to notify that there have been changes.
And since you bind to the ENTIRE collection and you need to check it all, then when you change any of its elements, you need to replace the collection instance.
Because otherwise the Binding will (conditionally) just check if it's another instance of the collection or not. And if the same, it will not update, even if the elements of the collection are already different.

Simple example:

using Simplified;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Core2022.SO.SiegfriedV
{
    public class IntsViewModel : BaseInpc
    {
        private HashSet<int> _numbers = new HashSet<int>(Enumerable.Range(0, 10));

        public HashSet<int> Numbers { get => _numbers; private set => Set(ref _numbers, value); }

        public IntsViewModel()
        {
            AddIntCommand = new RelayCommand<int>(num =>
            {
                HashSet<int> copy = new HashSet<int>(Numbers);
                copy.Add(num);
                Numbers = copy;
            });

            RemoveIntCommand = new RelayCommand<int>(num =>
            {
                HashSet<int> copy = new HashSet<int>(Numbers);
                copy.Remove(num);
                Numbers = copy;
            });
        }

        public RelayCommand<int> AddIntCommand { get; }
        public RelayCommand<int> RemoveIntCommand { get; }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Windows;
using System.Windows.Data;

namespace Core2022.SO.SiegfriedV
{
    [ValueConversion(typeof(ISet<int>), typeof(Visibility))]
    public class VisibleIfListIntContains : IValueConverter
    {
        private static readonly Int32Converter converter = new Int32Converter();
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is not ISet<int> ints)
                return DependencyProperty.UnsetValue;

            if (parameter is not int num)
            {
                if (!converter.IsValid(parameter))
                    return DependencyProperty.UnsetValue;
                num = (int)(converter.ConvertFrom(parameter) ?? throw new Exception("God knows what happened."));
            }

            return ints.Contains(num)
                ? Visibility.Visible
                : Visibility.Collapsed;
        }

        // The reverse conversion in such logic, in principle, will not work,
        // since it is impossible to replace the collection itself with a new instance from the converter.
        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }

        private VisibleIfListIntContains() { }
        public static VisibleIfListIntContains Instance { get; } = new VisibleIfListIntContains();
    }
}

namespace Core2022.SO.SiegfriedV
{
    // Helper class for automatically converting a string (TextBox.Text) to an integer.
    public class DataProxy
    {
        public int Number { get; set; }
    }
}

<Window x:Class="Core2022.SO.SiegfriedV.IntsWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Core2022.SO.SiegfriedV"
        mc:Ignorable="d"
        Title="IntsWindow" Height="450" Width="800"
        DataContext="{DynamicResource vm}">
    <Window.Resources>
        <local:IntsViewModel x:Key="vm"/>
        <local:DataProxy x:Key="proxy"/>
    </Window.Resources>
    <UniformGrid Columns="2">
        <UniformGrid HorizontalAlignment="Center" Columns="1">
            <TextBlock Text="0" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=0}" VerticalAlignment="Center"/>
            <TextBlock Text="1" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=1}" VerticalAlignment="Center"/>
            <TextBlock Text="2" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=2}" VerticalAlignment="Center"/>
            <TextBlock Text="3" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=3}" VerticalAlignment="Center"/>
            <TextBlock Text="4" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=4}" VerticalAlignment="Center"/>
            <TextBlock Text="5" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=5}" VerticalAlignment="Center"/>
            <TextBlock Text="6" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=6}" VerticalAlignment="Center"/>
            <TextBlock Text="7" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=7}" VerticalAlignment="Center"/>
            <TextBlock Text="8" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=8}" VerticalAlignment="Center"/>
            <TextBlock Text="9" Visibility="{Binding Numbers, Converter={x:Static local:VisibleIfListIntContains.Instance}, ConverterParameter=9}" VerticalAlignment="Center"/>
        </UniformGrid>
        <UniformGrid Columns="1">
            <TextBox VerticalAlignment="Center" Width="40" HorizontalContentAlignment="Center"
                     Text="{Binding Number, Source={StaticResource proxy}}"/>
            <UniformGrid Columns="2" HorizontalAlignment="Center" VerticalAlignment="Top">
                <Button Content="Add" Padding="15 5" Margin="10"
                        Command="{Binding AddIntCommand}"
                        CommandParameter="{Binding Number, Source={StaticResource proxy}}"/>
                <Button Content="Remove" Padding="15 5" Margin="10"
                        Command="{Binding RemoveIntCommand}"
                        CommandParameter="{Binding Number, Source={StaticResource proxy}}"/>
            </UniformGrid>
        </UniformGrid>
    </UniformGrid>
</Window>

The BaseInpc and RelayCommand classes were used.

P.S. If I misunderstood your task, please explain in more detail its details that are important to you.

Addition to the answer in connection with the clarification of the question

As far as I understand your code, my explanations can be applied to it like this:

    public partial class Macro : BaseInpc
    {
        private IEnumerable<int> _listFacesAllowed = Enumerable.Empty<int>();
        public IEnumerable<int> ListFacesAllowed
        {
            get => _listFacesAllowed;
            set => Set(ref _listFacesAllowed, value);
        }

    private void setAvailableFaces()
    {
        if (this.gpProfil == "I" || this.gpProfil == "H" || this.gpProfil == "U")
        {
            ListFacesAllowed = ListFacesAllowed.Concat(new int[] { 0, 1, 3 }).Distinct().ToArray();
        }
        else if (this.gpProfil == "L")
        {
            ListFacesAllowed = ListFacesAllowed.Concat(new int[] { 0, 2 }).Distinct().ToArray();
        }
        else if (this.gpProfil == "M")
        {
            ListFacesAllowed = ListFacesAllowed.Concat(new int[] { 0, 1, 2, 3 }).Distinct().ToArray();
        }
        if (this.type == 1)
        {
            if (this.isTraversingMacro)
            {
                if (this.gpProfil == "M")
                {
                    ListFacesAllowed = ListFacesAllowed.Except(new int[] { 0, 3 }).Distinct().ToArray();
                }
                else if (gpProfil == "I" || gpProfil == "H" || gpProfil == "U")
                {
                    if (this.name != "MV002" && this.name != "MV000")
                    {
                        ListFacesAllowed = ListFacesAllowed.Except(new int[] { 1, 2 }).Distinct().ToArray();
                    }
                    else
                    {
                        ListFacesAllowed = ListFacesAllowed.Except(new int[] { 1 }).Distinct().ToArray();
                    }
                }

            }
        }
    }

    [ValueConversion(typeof(ISet<int>), typeof(Visibility))]
    public class VisibleIfListIntContains : IValueConverter
    {
        private static readonly Int32Converter converter = new Int32Converter();
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is not IEnumerable<int> ints)
                return DependencyProperty.UnsetValue;

            if (parameter is not int num)
            {
                if (!converter.IsValid(parameter))
                    return DependencyProperty.UnsetValue;
                num = (int)(converter.ConvertFrom(parameter) ?? throw new Exception("God knows what happened."));
            }

            return ints.Contains(num)
                ? Visibility.Visible
                : Visibility.Collapsed;
        }

        // The reverse conversion in such logic, in principle, will not work,
        // since it is impossible to replace the collection itself with a new instance from the converter.
        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }

        private VisibleIfListIntContains() { }
        public static VisibleIfListIntContains Instance { get; } = new VisibleIfListIntContains();
    }

A slightly more optimal implementation of the method:

    private static readonly ReadOnlyCollection<int>
        facesEmpty = Array.AsReadOnly(Array.Empty<int>()),
        faces013 = Array.AsReadOnly(new int[] { 0, 1, 3 }),
        faces02 = Array.AsReadOnly(new int[] { 0, 2 }),
        faces0123 = Array.AsReadOnly(new int[] { 0, 1, 2, 3 }),
        faces03 = Array.AsReadOnly(new int[] { 0, 3 }),
        faces12 = Array.AsReadOnly(new int[] { 1, 2}),
        faces1 = Array.AsReadOnly(new int[] { 1 });

    private void setAvailableFaces()
    {
        IEnumerable<int> newlistFaces = this.gpProfil switch
        {
            "I" or "H" or "U" => faces013,
            "L" => faces02,
            "M" => faces0123,
            _ => facesEmpty
        };

        if (newlistFaces != facesEmpty && this.type == 1 && this.isTraversingMacro)
        {
            newlistFaces = this.gpProfil switch
            {
                "M" => newlistFaces.Except(faces03),
                "I" or "H" or "U" => this.name switch
                {
                    "MV002" or "MV000" => newlistFaces.Except(faces1),
                    _ => newlistFaces.Except(faces12)
                },
                _=> newlistFaces
            };
        }
        ListFacesAllowed = newlistFaces;
    }

thanks for answer. First, in fact I guess I missunderstand something with binding. (see my last comment to Andy). Then about the task, I have 4 faces (0 = front, 1 = Top, 2 = Bottom, 3 = Behind). Depending on many parameters of my object (type of element, type of operation selected...), I may activate/unactivate possibility to select some of faces (In fact I now have only an `ObservableCollection). To do so, I made a function `setAvailableFaces()`, (I use only Clear(), Add(int), and Remove(int). Then I don't understand in your code, the `IntsViewModel` part. — Siegfried.V, Oct 15 '22 at 11:57
just edited my post, replacing by my actual code, and adding the code editing the ObservableCollection. Maybe easier to understand like that? The main thing I don't understand is : usually when I bind on an ObservableCollection, I can add/remove items without the need to explicitly execute NotifyPropertyChanged. But in that case I need to. — Siegfried.V, Oct 15 '22 at 12:12
@Siegfried.V , `ObservableCollection`, in such a task, does not make sense, because when you change an element of the collection, you need to call a recheck of the entire collection. This can only be done if you replace the collection instance. In my example, I used a `HashSet` to speed up the Contains method. But, if you do not think about optimization, then you can use any `IEnumerable`. — EldHasp, Oct 15 '22 at 12:57
@Siegfried.V , I supplemented the answer with an example of a more optimal implementation of the method. — EldHasp, Oct 16 '22 at 07:06
thanks, but I will leave it as I did. In fact, this is just a part of the method (didn't finish it yet). Then another question please : Why don't you use ObservableCollection, but IEnumerable? I tried to implement your code, but then the binding is not working anymore. — Siegfried.V, Oct 16 '22 at 07:23
@Siegfried.V , ObservableCollection solves the problem of notification of changes in its content: adding, deleting, replacing items. This will update the UI element that is bound to the changed collection item by its index. You do not have a binding on an index. Therefore, the use of ObservableCollection is meaningless. I used IEnumerable to demonstrate that any collection type can be used for your task. It is only important that if you need to change this collection, you need to replace it with another instance of the collection, and not just change the existing instance. — EldHasp, Oct 16 '22 at 08:36
Without seeing the full code, I can't tell why the binding doesn't work for you. In my answer, I gave a verified full working version of the example. If you create a minimal demo example of the Solution, which will demonstrate HOW you need to solve it and WHAT does not work there, and then upload it to GitHub - I will try to look at it and determine the causes of the problems. — EldHasp, Oct 16 '22 at 08:43
I understand. Thanks for your time, also was interesting to se more optimizated syntaxes in your code. — Siegfried.V, Oct 16 '22 at 15:39

Binding not working when modifying ObservableCollection

1 Answers1