Fix Dropdown invalid states issue.

Author: ChebanovDD

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/UITK/BindableUIElements/BindableDropdownField.cs

@@ -15,10 +15,10 @@ namespace UnityMvvmToolkit.UITK.BindableUIElements
     public partial class BindableDropdownField : DropdownField, IBindableCollection, IInitializable, IDisposable
     {
         private IProperty<string> _selectedItemProperty;
-        private IReadOnlyProperty<ObservableCollection<string>> _itemsSource;
-
         private PropertyBindingData _selectedItemBindingData;
+
         private PropertyBindingData _itemsSourceBindingData;
+        private IReadOnlyProperty<ObservableCollection<string>> _itemsSource;
 
         public void Initialize()
         {
@@ -27,102 +27,155 @@ public void Initialize()
 
         public void Dispose()
         {
-            choices.Clear();
+            RemoveAllItems();
         }
-        
+
         public void SetBindingContext(IBindingContext context, IObjectProvider objectProvider)
         {
-            if (string.IsNullOrWhiteSpace(BindingItemsSourcePath) == false)
+            if (string.IsNullOrWhiteSpace(BindingItemsSourcePath))
             {
-                _itemsSourceBindingData ??= BindingItemsSourcePath.ToPropertyBindingData();
-                _itemsSource = objectProvider
-                    .RentReadOnlyProperty<ObservableCollection<string>>(context, _itemsSourceBindingData);
-                _itemsSource.Value.CollectionChanged += OnItemsCollectionChanged;
-                choices = new List<string>(_itemsSource.Value);
+                return;
             }
-            
+
+            _itemsSourceBindingData ??= BindingItemsSourcePath.ToPropertyBindingData();
+
+            _itemsSource =
+                objectProvider.RentReadOnlyProperty<ObservableCollection<string>>(context, _itemsSourceBindingData);
+            _itemsSource.Value.CollectionChanged += OnItemsCollectionChanged;
+
+            AddItems(_itemsSource.Value);
+
             if (string.IsNullOrWhiteSpace(BindingSelectedItemPath) == false)
             {
                 _selectedItemBindingData ??= BindingSelectedItemPath.ToPropertyBindingData();
+
                 _selectedItemProperty = objectProvider.RentProperty<string>(context, _selectedItemBindingData);
-                _selectedItemProperty.ValueChanged += OnSelectedItemValueChanged;
-                
-                var isContains = choices.Contains(_selectedItemProperty.Value);
-                if (isContains == true)
+
+                if (string.IsNullOrWhiteSpace(_selectedItemProperty.Value))
+                {
+                    _selectedItemProperty.Value = choices.Count > 0 ? choices[0] : default;
+                }
+                else
                 {
                     UpdateControlValue(_selectedItemProperty.Value);
                 }
-                
-                this.RegisterValueChangedCallback(OnControlValueChanged);
-                _selectedItemProperty.Value = choices.Count > 0 ? choices[0] : default;
+
+                _selectedItemProperty.ValueChanged += OnSelectedItemValueChanged;
+                this.RegisterValueChangedCallback(OnControlSelectedValueChanged);
             }
         }
 
+        public virtual void ResetBindingContext(IObjectProvider objectProvider)
+        {
+            if (_itemsSource is null)
+            {
+                return;
+            }
+
+            _itemsSource.Value.CollectionChanged -= OnItemsCollectionChanged;
+            objectProvider.ReturnReadOnlyProperty(_itemsSource);
+            _itemsSource = null;
+
+            if (_selectedItemProperty is not null)
+            {
+                _selectedItemProperty.ValueChanged -= OnSelectedItemValueChanged;
+                objectProvider.ReturnProperty(_selectedItemProperty);
+                _selectedItemProperty = null;
+
+                this.UnregisterValueChangedCallback(OnControlSelectedValueChanged);
+            }
+
+            RemoveAllItems();
+        }
+
         protected virtual void OnItemsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
             if (e.Action == NotifyCollectionChangedAction.Add)
             {
                 foreach (string newItem in e.NewItems)
                 {
-                    choices.Add(newItem);
+                    AddItem(newItem);
                 }
             }
 
             if (e.Action == NotifyCollectionChangedAction.Remove)
             {
                 foreach (string oldItem in e.OldItems)
                 {
-                    choices.Remove(oldItem);
+                    RemoveItem(oldItem);
                 }
             }
-            
+
             if (e.Action == NotifyCollectionChangedAction.Reset)
             {
-                choices.Clear();
+                if (_itemsSource.Value.Count == 0)
+                {
+                    RemoveAllItems();
+                }
+                else
+                {
+                    throw new InvalidOperationException("Action not supported.");
+                }
             }
         }
 
-        public virtual void ResetBindingContext(IObjectProvider objectProvider)
+        protected virtual void OnControlSelectedValueChanged(ChangeEvent<string> e)
+        {
+            _selectedItemProperty.Value = e.newValue;
+        }
+
+        private void OnSelectedItemValueChanged(object sender, string newValue)
         {
-            if (_selectedItemProperty != null)
+            UpdateControlValue(newValue);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected virtual void UpdateControlValue(string selectedItem)
+        {
+            if (choices.Any() && choices.Contains(selectedItem) == false)
             {
-                _selectedItemProperty.ValueChanged -= OnSelectedItemValueChanged;
-                objectProvider.ReturnProperty(_selectedItemProperty);
-                _selectedItemProperty = null;
-                this.UnregisterValueChangedCallback(OnControlValueChanged);
+                throw new InvalidOperationException($"\"{selectedItem}\" is not presented in the collection.");
             }
-            
-            if (_itemsSource != null)
+
+            SetValueWithoutNotify(selectedItem);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void AddItems(IEnumerable<string> items)
+        {
+            foreach (var item in items)
             {
-                _itemsSource.Value.CollectionChanged -= OnItemsCollectionChanged;
-                choices = new List<string>();
-                objectProvider.ReturnReadOnlyProperty(_itemsSource);
-                _itemsSource = null;
+                AddItem(item);
             }
-
-            UpdateControlValue(default);
         }
 
-        protected virtual void OnControlValueChanged(ChangeEvent<string> e)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void AddItem(string item)
         {
-            _selectedItemProperty.Value = e.newValue;
+            if (string.IsNullOrWhiteSpace(item))
+            {
+                throw new NullReferenceException("Item cannot be null or empty.");
+            }
+
+            choices.Add(item);
         }
 
-        private void OnSelectedItemValueChanged(object sender, string newValue)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void RemoveItem(string item)
         {
-            var isContains = choices.Contains(newValue);
-            if (isContains == false)
+            choices.Remove(item);
+
+            if (value == item)
             {
-                return;
+                value = choices.Count == 0 ? default : choices[^1];
             }
-            
-            UpdateControlValue(newValue);
         }
-        
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected virtual void UpdateControlValue(string newValue)
+        private void RemoveAllItems()
         {
-            SetValueWithoutNotify(newValue);
+            choices.Clear();
+            value = default;
         }
     }
 }

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/UITK/BindableUIElements/Uxmls/BindableDropdownField.Uxml.cs

@@ -5,9 +5,8 @@ namespace UnityMvvmToolkit.UITK.BindableUIElements
 {
     partial class BindableDropdownField
     {
-        public string BindingSelectedItemPath { get; private set; }
-
         public string BindingItemsSourcePath { get; private set; }
+        public string BindingSelectedItemPath { get; private set; }
 
         public new class UxmlFactory : UxmlFactory<BindableDropdownField, UxmlTraits>
         {
@@ -19,8 +18,8 @@ partial class BindableDropdownField
         {
             // ReSharper disable once InconsistentNaming
             #pragma warning disable 649
+            [UnityEngine.SerializeField] private string BindingItemsSourcePath;            
             [UnityEngine.SerializeField] private string BindingSelectedItemPath;
-            [UnityEngine.SerializeField] private string BindingItemsSourcePath;
             #pragma warning restore 649
 
             public override object CreateInstance() => new BindableDropdownField();
@@ -29,27 +28,26 @@ public override void Deserialize(object visualElement)
                 base.Deserialize(visualElement);
 
                 var bindableDropdownField = visualElement.As<BindableDropdownField>();
-                bindableDropdownField.BindingSelectedItemPath = BindingSelectedItemPath;
                 bindableDropdownField.BindingItemsSourcePath = BindingItemsSourcePath;
+                bindableDropdownField.BindingSelectedItemPath = BindingSelectedItemPath;
             }
         }
 #else
         public new class UxmlTraits : DropdownField.UxmlTraits
         {
-            private readonly UxmlStringAttributeDescription _bindingSelectedItemPath = new()
-                { name = "binding-selected-item-path", defaultValue = "" };
-
             private readonly UxmlStringAttributeDescription _bindingItemsSourcePath = new()
                 { name = "binding-items-source-path", defaultValue = "" };
 
+            private readonly UxmlStringAttributeDescription _bindingSelectedItemPath = new()
+                { name = "binding-selected-item-path", defaultValue = "" };
+
             public override void Init(VisualElement visualElement, IUxmlAttributes bag, CreationContext context)
             {
                 base.Init(visualElement, bag, context);
 
                 var bindableDropdownField = visualElement.As<BindableDropdownField>();
-                
-                bindableDropdownField.BindingSelectedItemPath = _bindingSelectedItemPath.GetValueFromBag(bag, context);
                 bindableDropdownField.BindingItemsSourcePath = _bindingItemsSourcePath.GetValueFromBag(bag, context);
+                bindableDropdownField.BindingSelectedItemPath = _bindingSelectedItemPath.GetValueFromBag(bag, context);
             }
         }
 #endif