**New**:

- Added *Rebind* functionality to all Observable classes (*ObservableField*, *ObservableList*, *ObservableDictionary*) allowing rebinding to new data sources without losing existing observers
- Added *Rebind* methods to all Observable Resolver classes (*ObservableResolverField*, *ObservableResolverList*, *ObservableResolverDictionary*) to rebind to new origin collections and resolver functions
- Added new *IObservableResolverField* interface with *Rebind* method for resolver field implementations

Author: Miguel Cartier

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2025-11-03
+
+**New**:
+- Added *Rebind* functionality to all Observable classes (*ObservableField*, *ObservableList*, *ObservableDictionary*) allowing rebinding to new data sources without losing existing observers
+- Added *Rebind* methods to all Observable Resolver classes (*ObservableResolverField*, *ObservableResolverList*, *ObservableResolverDictionary*) to rebind to new origin collections and resolver functions
+- Added new *IObservableResolverField* interface with *Rebind* method for resolver field implementations
+
 ## [0.6.7] - 2025-04-07
 
 **New**:

Runtime/ObservableDictionary.cs

@@ -176,6 +176,17 @@ public interface IObservableResolverDictionary<TKey, TValue, TKeyOrigin, TValueO
 		/// Clear's to the origin dictionary
 		/// </remarks>
 		void ClearOrigin();
+
+		/// <summary>
+		/// Rebinds this dictionary to a new origin dictionary and resolver functions without losing existing observers.
+		/// The internal dictionary will be rebuilt from the new origin dictionary using the new resolvers.
+		/// </summary>
+		/// <param name="dictionary">The new origin dictionary to bind to</param>
+		/// <param name="fromOrignResolver">The new function to convert from origin types to this dictionary's types</param>
+		/// <param name="toOrignResolver">The new function to convert from this dictionary's types to origin types</param>
+		void Rebind(IDictionary<TKeyOrigin, TValueOrigin> dictionary,
+			Func<KeyValuePair<TKeyOrigin, TValueOrigin>, KeyValuePair<TKey, TValue>> fromOrignResolver,
+			Func<TKey, TValue, KeyValuePair<TKeyOrigin, TValueOrigin>> toOrignResolver);
 	}
 
 	/// <inheritdoc />
@@ -193,7 +204,7 @@ public class ObservableDictionary<TKey, TValue> : IObservableDictionary<TKey, TV
 		/// <inheritdoc />
 		public ReadOnlyDictionary<TKey, TValue> ReadOnlyDictionary => new ReadOnlyDictionary<TKey, TValue>(Dictionary);
 
-		protected virtual IDictionary<TKey, TValue> Dictionary { get; }
+		protected virtual IDictionary<TKey, TValue> Dictionary { get; set; }
 
 		private ObservableDictionary() { }
 
@@ -203,6 +214,15 @@ public ObservableDictionary(IDictionary<TKey, TValue> dictionary)
 			ObservableUpdateFlag = ObservableUpdateFlag.KeyUpdateOnly;
 		}
 
+		/// <summary>
+		/// Rebinds this dictionary to a new dictionary without losing existing observers.
+		/// </summary>
+		/// <param name="dictionary">The new dictionary to bind to</param>
+		public void Rebind(IDictionary<TKey, TValue> dictionary)
+		{
+			Dictionary = dictionary;
+		}
+
 		/// <inheritdoc cref="Dictionary{TKey,TValue}.this" />
 		public TValue this[TKey key]
 		{
@@ -468,14 +488,14 @@ private int AdjustIndex(int index, Action<TKey, TValue, TValue, ObservableUpdate
 		}
 	}
 
-	/// <inheritdoc />
+	/// <inheritdoc cref="IObservableResolverDictionary{TKey, TValue, TKeyOrigin, TValueOrigin}"/>
 	public class ObservableResolverDictionary<TKey, TValue, TKeyOrigin, TValueOrigin> : 
 		ObservableDictionary<TKey, TValue>,
 		IObservableResolverDictionary<TKey, TValue, TKeyOrigin, TValueOrigin>
 	{
-		private readonly IDictionary<TKeyOrigin, TValueOrigin> _dictionary;
-		private readonly Func<TKey, TValue, KeyValuePair<TKeyOrigin, TValueOrigin>> _toOrignResolver;
-		private readonly Func<KeyValuePair<TKeyOrigin, TValueOrigin>, KeyValuePair<TKey, TValue>> _fromOrignResolver;
+		private IDictionary<TKeyOrigin, TValueOrigin> _dictionary;
+		private Func<TKey, TValue, KeyValuePair<TKeyOrigin, TValueOrigin>> _toOrignResolver;
+		private Func<KeyValuePair<TKeyOrigin, TValueOrigin>, KeyValuePair<TKey, TValue>> _fromOrignResolver;
 
 		/// <inheritdoc />
 		public ReadOnlyDictionary<TKeyOrigin, TValueOrigin> OriginDictionary => new ReadOnlyDictionary<TKeyOrigin, TValueOrigin>(_dictionary);
@@ -495,6 +515,23 @@ public ObservableResolverDictionary(IDictionary<TKeyOrigin, TValueOrigin> dictio
 			}
 		}
 
+		/// <inheritdoc />
+		public void Rebind(IDictionary<TKeyOrigin, TValueOrigin> dictionary,
+			Func<KeyValuePair<TKeyOrigin, TValueOrigin>, KeyValuePair<TKey, TValue>> fromOrignResolver,
+			Func<TKey, TValue, KeyValuePair<TKeyOrigin, TValueOrigin>> toOrignResolver)
+		{
+			_dictionary = dictionary;
+			_toOrignResolver = toOrignResolver;
+			_fromOrignResolver = fromOrignResolver;
+
+			// Rebuild the internal dictionary from the new origin dictionary
+			Dictionary.Clear();
+			foreach (var pair in dictionary)
+			{
+				Dictionary.Add(fromOrignResolver(pair));
+			}
+		}
+
 		/// <inheritdoc />
 		public TValueOrigin GetOriginValue(TKey key)
 		{

Runtime/ObservableField.cs

@@ -50,6 +50,26 @@ public interface IObservableField<T> : IObservableFieldReader<T>
 		/// The field value with possibility to be changed
 		/// </summary>
 		new T Value { get; set; }
+
+		/// <summary>
+		/// Rebinds this field to a new value without losing existing observers.
+		/// </summary>
+		/// <param name="initialValue">The new initial value for the field</param>
+		void Rebind(T initialValue);
+	}
+
+	/// <inheritdoc />
+	/// <remarks>
+	/// A resolver field with the possibility to rebind to new resolver functions
+	/// </remarks>
+	public interface IObservableResolverField<T> : IObservableField<T>
+	{
+		/// <summary>
+		/// Rebinds this field to new resolver functions without losing existing observers
+		/// </summary>
+		/// <param name="fieldResolver">The new getter function for the field</param>
+		/// <param name="fieldSetter">The new setter function for the field</param>
+		void Rebind(Func<T> fieldResolver, Action<T> fieldSetter);
 	}
 
 	/// <inheritdoc />
@@ -84,6 +104,12 @@ public ObservableField(T initialValue)
 
 		public static implicit operator T(ObservableField<T> value) => value.Value;
 
+		/// <inheritdoc />
+		public void Rebind(T initialValue)
+		{
+			_value = initialValue;
+		}
+
 		/// <inheritdoc />
 		public void Observe(Action<T, T> onUpdate)
 		{
@@ -137,11 +163,11 @@ protected void InvokeUpdate(T previousValue)
 		}
 	}
 
-	/// <inheritdoc />
-	public class ObservableResolverField<T> : ObservableField<T>
+	/// <inheritdoc cref="IObservableResolverField{T}"/>
+	public class ObservableResolverField<T> : ObservableField<T>, IObservableResolverField<T>
 	{
-		private readonly Func<T> _fieldResolver;
-		private readonly Action<T> _fieldSetter;
+		private Func<T> _fieldResolver;
+		private Action<T> _fieldSetter;
 
 		/// <inheritdoc cref="IObservableField{T}.Value" />
 		public override T Value
@@ -165,6 +191,17 @@ public ObservableResolverField(Func<T> fieldResolver, Action<T> fieldSetter)
 			_fieldSetter = fieldSetter;
 		}
 
+		/// <summary>
+		/// Rebinds this field to new resolver functions without losing existing observers
+		/// </summary>
+		/// <param name="fieldResolver">The new getter function for the field</param>
+		/// <param name="fieldSetter">The new setter function for the field</param>
+		public void Rebind(Func<T> fieldResolver, Action<T> fieldSetter)
+		{
+			_fieldResolver = fieldResolver;
+			_fieldSetter = fieldSetter;
+		}
+
 		public static implicit operator T(ObservableResolverField<T> value) => value.Value;
 	}
 }

Runtime/ObservableList.cs

@@ -94,7 +94,7 @@ public interface IObservableList<T> : IObservableListReader<T>
 	/// <remarks>
 	/// This interface resolves between 2 lists with different types of values
 	/// </remarks>
-	public interface IObservableResolverListReader<T, TOrigin> : IObservableListReader<T>
+	public interface IObservableResolverListReader<T, out TOrigin> : IObservableListReader<T>
 	{
 		/// <summary>
 		/// The Original List that is being resolved across the entire interface
@@ -134,6 +134,15 @@ public interface IObservableResolverList<T, TOrigin> :
 		/// Clear's to the origin list
 		/// </remarks>
 		void ClearOrigin();
+
+		/// <summary>
+		/// Rebinds this list to a new origin list and resolver functions without losing existing observers.
+		/// The internal list will be rebuilt from the new origin list using the new resolvers.
+		/// </summary>
+		/// <param name="originList">The new origin list to bind to</param>
+		/// <param name="fromOrignResolver">The new function to convert from origin type to this list's type</param>
+		/// <param name="toOrignResolver">The new function to convert from this list's type to origin type</param>
+		void Rebind(IList<TOrigin> originList, Func<TOrigin, T> fromOrignResolver, Func<T, TOrigin> toOrignResolver);
 	}
 
 	/// <inheritdoc />
@@ -160,7 +169,7 @@ public T this[int index]
 		/// <inheritdoc />
 		public IReadOnlyList<T> ReadOnlyList => new List<T>(List);
 
-		protected virtual List<T> List { get; }
+		protected virtual List<T> List { get; set; }
 
 		protected ObservableList() { }
 
@@ -169,6 +178,15 @@ public ObservableList(IList<T> list)
 			List = list as List<T> ?? list.ToList();
 		}
 
+		/// <summary>
+		/// Rebinds this list to a new list without losing existing observers.
+		/// </summary>
+		/// <param name="list">The new list to bind to</param>
+		public void Rebind(IList<T> list)
+		{
+			List = list as List<T> ?? list.ToList();
+		}
+
 		/// <inheritdoc cref="List{T}.GetEnumerator"/>
 		public List<T>.Enumerator GetEnumerator()
 		{
@@ -332,12 +350,15 @@ private int AdjustIndex(int index, Action<int, T, T, ObservableUpdateType> actio
 		}
 	}
 
-	/// <inheritdoc />
+	/// <inheritdoc cref="IObservableResolverList{T, TOrigin}"/>
+	/// <remarks>
+	/// This class resolves between 2 lists with different types of values
+	/// </remarks>
 	public class ObservableResolverList<T, TOrigin> : ObservableList<T>, IObservableResolverList<T, TOrigin>
 	{
-		private readonly IList<TOrigin> _originList;
-		private readonly Func<TOrigin, T> _fromOrignResolver;
-		private readonly Func<T, TOrigin> _toOrignResolver;
+		private IList<TOrigin> _originList;
+		private Func<TOrigin, T> _fromOrignResolver;
+		private Func<T, TOrigin> _toOrignResolver;
 
 		/// <inheritdoc />
 		public IReadOnlyList<TOrigin> OriginList => new List<TOrigin>(_originList);
@@ -357,6 +378,23 @@ public ObservableResolverList(IList<TOrigin> originList,
 			}
 		}
 
+		/// <inheritdoc />
+		public void Rebind(IList<TOrigin> originList, 
+			Func<TOrigin, T> fromOrignResolver, 
+			Func<T, TOrigin> toOrignResolver)
+		{
+			_originList = originList;
+			_fromOrignResolver = fromOrignResolver;
+			_toOrignResolver = toOrignResolver;
+
+			// Rebuild the internal list from the new origin list
+			List.Clear();
+			for (var i = 0; i < originList.Count; i++)
+			{
+				List.Add(fromOrignResolver(originList[i]));
+			}
+		}
+
 		/// <inheritdoc />
 		public override void Add(T data)
 		{

Tests/Editor/OberservableResolverListTest.cs

@@ -66,5 +66,70 @@ public void ClearOrigin_ClearsOriginList()
 
 			_mockList.Received().Clear();
 		}
+
+		[Test]
+		public void Rebind_ChangesOriginList()
+		{
+			// Add initial data
+			_list.AddOrigin("1");
+			_list.AddOrigin("2");
+
+			// Create new origin list and rebind
+			var newOriginList = new List<string> { "10", "20", "30", "40" };
+			_list.Rebind(
+				newOriginList,
+				origin => int.Parse(origin),
+				value => value.ToString());
+
+			// Verify new list is being used
+			Assert.AreEqual(4, _list.Count);
+			Assert.AreEqual(10, _list[0]);
+			Assert.AreEqual(20, _list[1]);
+			Assert.AreEqual(30, _list[2]);
+			Assert.AreEqual(40, _list[3]);
+
+			// Verify add operation uses new origin list
+			_list.Add(50);
+			Assert.AreEqual("50", newOriginList[4]);
+		}
+
+		[Test]
+		public void Rebind_KeepsObservers()
+		{
+			// Setup observer
+			var observerCalls = 0;
+			_list.Observe((index, prev, curr, type) => observerCalls++);
+
+			// Create new origin list and rebind
+			var newOriginList = new List<string> { "100", "200" };
+			_list.Rebind(
+				newOriginList,
+				origin => int.Parse(origin),
+				value => value.ToString());
+
+			// Trigger update and verify observer is still active
+			_list.Add(300);
+			Assert.AreEqual(1, observerCalls);
+		}
+
+		[Test]
+		public void Rebind_ChangesResolvers()
+		{
+			// Create new origin list with different format and rebind with new resolvers
+			var newOriginList = new List<string> { "value:10", "value:20" };
+			_list.Rebind(
+				newOriginList,
+				origin => int.Parse(origin.Split(':')[1]),
+				value => $"value:{value}");
+
+			// Verify new resolvers are being used
+			Assert.AreEqual(2, _list.Count);
+			Assert.AreEqual(10, _list[0]);
+			Assert.AreEqual(20, _list[1]);
+
+			// Verify add operation uses new resolver
+			_list.Add(30);
+			Assert.AreEqual("value:30", newOriginList[2]);
+		}
 	}
 }

Tests/Editor/ObservableDictionaryTest.cs

@@ -280,5 +280,37 @@ public void StopObservingAll_NotObserving_DoesNothing()
 
 			_caller.DidNotReceive().Call(Arg.Any<int>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<ObservableUpdateType>());
 		}
+
+		[Test]
+		public void RebindCheck_BaseClass()
+		{
+			// Add initial data
+			_dictionary.Add(1, 100);
+			_dictionary.Add(2, 200);
+
+			// Setup key-specific observer (this works with default KeyUpdateOnly flag)
+			_dictionary.Observe(40, _caller.Call);
+
+			// Create new dictionary and rebind
+			var newDictionary = new Dictionary<int, int> { { 10, 1000 }, { 20, 2000 }, { 30, 3000 } };
+			_dictionary.Rebind(newDictionary);
+
+			// Verify new dictionary is being used
+			Assert.AreEqual(3, _dictionary.Count);
+			Assert.IsTrue(_dictionary.ContainsKey(10));
+			Assert.IsTrue(_dictionary.ContainsKey(20));
+			Assert.IsTrue(_dictionary.ContainsKey(30));
+			Assert.AreEqual(1000, _dictionary[10]);
+			Assert.AreEqual(2000, _dictionary[20]);
+			Assert.AreEqual(3000, _dictionary[30]);
+
+			// Verify old keys are no longer present
+			Assert.IsFalse(_dictionary.ContainsKey(1));
+			Assert.IsFalse(_dictionary.ContainsKey(2));
+
+			// Verify observer still works after rebind
+			_dictionary.Add(40, 4000);
+			_caller.Received(1).Call(40, 0, 4000, ObservableUpdateType.Added);
+		}
 	}
 }